{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Customer churn augment\n",
    "\n",
    "This notebook is derived from [customer churn augment notebook](https://github.com/NVIDIA/data-science-blueprints/blob/main/churn/augment.ipynb), please refer to this [git repo](https://github.com/NVIDIA/data-science-blueprints/tree/main/churn) for more detail information.\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "# notebook parameters\n",
    "\n",
    "import os\n",
    "\n",
    "spark_master = os.getenv(\"SPARK_MASTER_URL\", \"spark://ip:port\")\n",
    "app_name = \"augment\"\n",
    "dataRoot = os.getenv(\"DATA_ROOT\", \"data\")\n",
    "input_file = os.path.join(dataRoot, \"WA_Fn-UseC_-Telco-Customer-Churn-.csv\")\n",
    "output_mode = \"overwrite\"\n",
    "output_kind = \"parquet\"\n",
    "driver_memory = '12g'\n",
    "executor_memory = '8g'\n",
    "\n",
    "dup_times = 100\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import churn.augment\n",
    "\n",
    "churn.augment.register_options(\n",
    "    spark_master = spark_master,\n",
    "    app_name = app_name,\n",
    "    input_file = input_file,\n",
    "    output_mode = output_mode,\n",
    "    output_kind = output_kind,\n",
    "    driver_memory = driver_memory,\n",
    "    executor_memory = executor_memory,\n",
    "    dup_times = dup_times,\n",
    "    use_decimal = True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sanity-checking\n",
    "\n",
    "We're going to make sure we're running with a compatible JVM first — if we run on macOS, we might get one that doesn't work with Scala."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import getenv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/data/usr/lib/jvm/java-8-openjdk-amd64'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getenv(\"JAVA_HOME\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spark setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyspark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <div>\n",
       "                <p><b>SparkSession - hive</b></p>\n",
       "                \n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://10.19.183.210:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v3.2.0</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>spark://yuanli-System-Product-Name:7077</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>PySparkShell</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        \n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "<pyspark.sql.session.SparkSession at 0x7f2751631520>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session = pyspark.sql.SparkSession.builder \\\n",
    "    .master(spark_master) \\\n",
    "    .appName(app_name) \\\n",
    "    .config(\"spark.driver.memory\", driver_memory) \\\n",
    "    .config(\"spark.executor.memory\", executor_memory) \\\n",
    "    .getOrCreate()\n",
    "session"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Schema definition\n",
    "\n",
    "Most of the fields are strings representing booleans or categoricals, but a few (`tenure`, `MonthlyCharges`, and `TotalCharges`) are numeric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "read 7043 records from source dataset (7032 non-null records)\n"
     ]
    }
   ],
   "source": [
    "from churn.augment import load_supplied_data\n",
    "\n",
    "df = load_supplied_data(session, input_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Splitting the data frame\n",
    "\n",
    "The training data schema looks like this:\n",
    "\n",
    "- customerID\n",
    "- gender\n",
    "- SeniorCitizen\n",
    "- Partner\n",
    "- Dependents\n",
    "- tenure\n",
    "- PhoneService\n",
    "- MultipleLines\n",
    "- InternetService\n",
    "- OnlineSecurity\n",
    "- OnlineBackup\n",
    "- DeviceProtection\n",
    "- TechSupport\n",
    "- StreamingTV\n",
    "- StreamingMovies\n",
    "- Contract\n",
    "- PaperlessBilling\n",
    "- PaymentMethod\n",
    "- MonthlyCharges\n",
    "- TotalCharges\n",
    "- Churn\n",
    "\n",
    "We want to divide the data frame into several frames that we can join together in an ETL job.\n",
    "\n",
    "Those frames will look like this:\n",
    "\n",
    "- **Customer metadata**\n",
    "  - customerID\n",
    "  - gender\n",
    "  - date of birth (we'll derive age and senior citizen status from this)\n",
    "  - Partner\n",
    "  - Dependents\n",
    "  - (nominal) MonthlyCharges\n",
    "- **Billing events**\n",
    "  - customerID\n",
    "  - date (we'll derive tenure from the number/duration of billing events)\n",
    "  - kind (one of \"AccountCreation\", \"Charge\", or \"AccountTermination\")\n",
    "  - value (either a positive nonzero amount or 0.00; we'll derive TotalCharges from the sum of amounts and Churn from the existence of an AccountTermination event)\n",
    "- **Customer phone features**\n",
    "  - customerID\n",
    "  - feature (one of \"PhoneService\" or \"MultipleLines\")\n",
    "- **Customer internet features**\n",
    "  - customerID\n",
    "  - feature (one of \"InternetService\", \"OnlineSecurity\", \"OnlineBackup\", \"DeviceProtection\", \"TechSupport\", \"StreamingTV\", \"StreamingMovies\")\n",
    "  - value (one of \"Fiber\", \"DSL\", \"Yes\", \"No\")\n",
    "- **Customer account features**\n",
    "  - customerID\n",
    "  - feature (one of \"Contract\", \"PaperlessBilling\", \"PaymentMethod\")\n",
    "  - value (one of \"Month-to-month\", \"One year\", \"Two year\", \"No\", \"Yes\", \"Credit card (automatic)\", \"Mailed check\", \"Bank transfer (automatic)\", \"Electronic check\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- customerID: string (nullable = true)\n",
      " |-- gender: string (nullable = true)\n",
      " |-- SeniorCitizen: string (nullable = true)\n",
      " |-- Partner: string (nullable = true)\n",
      " |-- Dependents: string (nullable = true)\n",
      " |-- tenure: double (nullable = true)\n",
      " |-- PhoneService: string (nullable = true)\n",
      " |-- MultipleLines: string (nullable = true)\n",
      " |-- InternetService: string (nullable = true)\n",
      " |-- OnlineSecurity: string (nullable = true)\n",
      " |-- OnlineBackup: string (nullable = true)\n",
      " |-- DeviceProtection: string (nullable = true)\n",
      " |-- TechSupport: string (nullable = true)\n",
      " |-- StreamingTV: string (nullable = true)\n",
      " |-- StreamingMovies: string (nullable = true)\n",
      " |-- Contract: string (nullable = true)\n",
      " |-- PaperlessBilling: string (nullable = true)\n",
      " |-- PaymentMethod: string (nullable = true)\n",
      " |-- MonthlyCharges: double (nullable = true)\n",
      " |-- TotalCharges: double (nullable = true)\n",
      " |-- Churn: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start by generating a series of monthly charges, then a series of account creation events, and finally a series of churn events. `billingEvents` is the data frame containing all of these events:  account activation, account termination, and individual payment events."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/yuanli/work/spark-3.2.0-bin-hadoop3.2/python/pyspark/sql/functions.py:1353: FutureWarning: Deprecated in 3.2, use shiftright instead.\n",
      "  warnings.warn(\"Deprecated in 3.2, use shiftright instead.\", FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from churn.augment import billing_events\n",
    "billingEvents = billing_events(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our next step is to generate customer metadata, which includes the following fields:\n",
    "\n",
    "  - gender\n",
    "  - date of birth (we'll derive age and senior citizen status from this)\n",
    "  - Partner\n",
    "  - Dependents\n",
    "  \n",
    "We'll calculate date of birth by using the hash of the customer ID as a pseudorandom number and then assuming that ages are uniformly distributed between 18-65 and exponentially distributed over 65."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:36:31,848 WARN conf.HiveConf: HiveConf of name hive.stats.jdbc.timeout does not exist\n",
      "2022-04-05 09:36:31,849 WARN conf.HiveConf: HiveConf of name hive.stats.retries.wait does not exist\n",
      "2022-04-05 09:36:33,683 WARN metastore.ObjectStore: Version information not found in metastore. hive.metastore.schema.verification is not enabled so recording the schema version 2.3.0\n",
      "2022-04-05 09:36:33,683 WARN metastore.ObjectStore: setMetaStoreSchemaVersion called but recording version is disabled: version = 2.3.0, comment = Set by MetaStore yuanli@127.0.1.1\n",
      "2022-04-05 09:36:33,811 WARN metastore.ObjectStore: Failed to get database global_temp, returning NoSuchObjectException\n",
      "2022-04-05 09:36:33,892 WARN rapids.GpuOverrides: \n",
      "! <LocalTableScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.LocalTableScanExec\n",
      "  @Expression <AttributeReference> name#326 could run on GPU\n",
      "  @Expression <AttributeReference> database#327 could run on GPU\n",
      "  @Expression <AttributeReference> description#328 could run on GPU\n",
      "  @Expression <AttributeReference> tableType#329 could run on GPU\n",
      "  @Expression <AttributeReference> isTemporary#330 could run on GPU\n",
      "\n",
      "2022-04-05 09:36:33,960 WARN rapids.GpuOverrides: \n",
      "        ! <RDDScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.RDDScanExec\n",
      "          @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "\n",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "from churn.augment import customer_meta\n",
    "customerMeta = customer_meta(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can generate customer phone features, which include:\n",
    "\n",
    "  - customerID\n",
    "  - feature (one of \"PhoneService\" or \"MultipleLines\")\n",
    "  - value (always \"Yes\"; there are no records for \"No\" or \"No Phone Service\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from churn.augment import phone_features\n",
    "customerPhoneFeatures = phone_features(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Customer internet features include:\n",
    "  - customerID\n",
    "  - feature (one of \"InternetService\", \"OnlineSecurity\", \"OnlineBackup\", \"DeviceProtection\", \"TechSupport\", \"StreamingTV\", \"StreamingMovies\")\n",
    "  - value (one of \"Fiber\", \"DSL\", \"Yes\" -- no records for \"No\" or \"No internet service\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from churn.augment import internet_features\n",
    "customerInternetFeatures = internet_features(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Customer account features include:\n",
    "\n",
    "  - customerID\n",
    "  - feature (one of \"Contract\", \"PaperlessBilling\", \"PaymentMethod\")\n",
    "  - value (one of \"Month-to-month\", \"One year\", \"Two year\", \"Yes\", \"Credit card (automatic)\", \"Mailed check\", \"Bank transfer (automatic)\", \"Electronic check\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from churn.augment import account_features\n",
    "customerAccountFeatures = account_features(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:36:36,792 WARN rapids.GpuOverrides: \n",
      "! <LocalTableScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.LocalTableScanExec\n",
      "  @Expression <AttributeReference> name#798 could run on GPU\n",
      "  @Expression <AttributeReference> database#799 could run on GPU\n",
      "  @Expression <AttributeReference> description#800 could run on GPU\n",
      "  @Expression <AttributeReference> tableType#801 could run on GPU\n",
      "  @Expression <AttributeReference> isTemporary#802 could run on GPU\n",
      "\n",
      "2022-04-05 09:36:37,142 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#816 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> kind#133 could run on GPU\n",
      "  @Expression <AttributeReference> value#136 could run on GPU\n",
      "  @Expression <AttributeReference> date#156 could run on GPU\n",
      "  @Expression <AttributeReference> month#315 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <Alias> Charge AS kind#133 could run on GPU\n",
      "            @Expression <Literal> Charge could run on GPU\n",
      "          @Expression <AttributeReference> value#136 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) AS date#156 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              @Expression <Cast> cast(-(cast(_we0#149 as bigint) + last_month#135L) as int) could run on GPU\n",
      "                @Expression <UnaryMinus> -(cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                  @Expression <Add> (cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                    @Expression <Cast> cast(_we0#149 as bigint) could run on GPU\n",
      "                      @Expression <AttributeReference> _we0#149 could run on GPU\n",
      "                    @Expression <AttributeReference> last_month#135L could run on GPU\n",
      "              !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "                @Partitioning <HashPartitioning> could run on GPU\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                  @Expression <AttributeReference> value#136 could run on GPU\n",
      "                  @Expression <Alias> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END AS last_month#135L could run on GPU\n",
      "                    @Expression <CaseWhen> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END could run on GPU\n",
      "                      @Expression <EqualTo> (Churn#20 = Yes) could run on GPU\n",
      "                        @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                        @Expression <Literal> Yes could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#0, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#0, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                      @Expression <Literal> 0 could run on GPU\n",
      "                  !Exec <GenerateExec> cannot run on GPU because not all expressions can be replaced\n",
      "                    @Expression <Explode> explode(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                      ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                        @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                          @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                            @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                            @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                        !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                          @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                    @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                      !Exec <FilterExec> cannot run on GPU because not all expressions can be replaced\n",
      "                        @Expression <And> ((atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) AND isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)))) could run on GPU\n",
      "                          @Expression <And> (atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) could run on GPU\n",
      "                            @Expression <AtLeastNNonNulls> atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) could run on GPU\n",
      "                              @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                              @Expression <AttributeReference> gender#1 could run on GPU\n",
      "                              @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                              @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "                              @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "                              @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <AttributeReference> PhoneService#6 could run on GPU\n",
      "                              @Expression <AttributeReference> MultipleLines#7 could run on GPU\n",
      "                              @Expression <AttributeReference> InternetService#8 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineSecurity#9 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineBackup#10 could run on GPU\n",
      "                              @Expression <AttributeReference> DeviceProtection#11 could run on GPU\n",
      "                              @Expression <AttributeReference> TechSupport#12 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingTV#13 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingMovies#14 could run on GPU\n",
      "                              @Expression <AttributeReference> Contract#15 could run on GPU\n",
      "                              @Expression <AttributeReference> PaperlessBilling#16 could run on GPU\n",
      "                              @Expression <AttributeReference> PaymentMethod#17 could run on GPU\n",
      "                              @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "                              @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                              @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                            @Expression <GreaterThan> (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0) could run on GPU\n",
      "                              @Expression <Size> size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) could run on GPU\n",
      "                                ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                                  @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                    @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                      @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                      @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                                  !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                    @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <Literal> 0 could run on GPU\n",
      "                          @Expression <IsNotNull> isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                            ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                              @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                  @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                  @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "          @Expression <Alias> AccountCreation AS kind#191 could run on GPU\n",
      "            @Expression <Literal> AccountCreation could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#192 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) AS date#200 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              !Expression <Cast> cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                @Expression <Add> ((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) could run on GPU\n",
      "                  @Expression <Subtract> (-tenure#270 - 1.0) could run on GPU\n",
      "                    @Expression <UnaryMinus> -tenure#270 could run on GPU\n",
      "                      @Expression <AttributeReference> tenure#270 could run on GPU\n",
      "                    @Expression <Literal> 1.0 could run on GPU\n",
      "                  @Expression <CaseWhen> CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END could run on GPU\n",
      "                    @Expression <EqualTo> (Churn#285 = Yes) could run on GPU\n",
      "                      @Expression <AttributeReference> Churn#285 could run on GPU\n",
      "                      @Expression <Literal> Yes could run on GPU\n",
      "                    @Expression <Cast> cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#265, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#265, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                    @Expression <Literal> 0.0 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "          @Expression <Alias> AccountTermination AS kind#258 could run on GPU\n",
      "            @Expression <Literal> AccountTermination could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#259 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END AS date#260 could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END could run on GPU\n",
      "              @Expression <EqualTo> (Churn#310 = Yes) could run on GPU\n",
      "                @Expression <AttributeReference> Churn#310 could run on GPU\n",
      "                @Expression <Literal> Yes could run on GPU\n",
      "              ! <AddMonths> add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "                @Expression <Literal> 2022-04-05 could run on GPU\n",
      "                @Expression <Cast> cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int) could run on GPU\n",
      "                  @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                    @Expression <Add> ((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                      @Expression <Add> (((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                        @Expression <Add> ((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                          @Expression <Add> (((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                            @Expression <Remainder> ((abs(xxhash64(customerID#290, 42), false) & 255) % 36) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (abs(xxhash64(customerID#290, 42), false) & 255) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 36 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 8) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                  @Expression <Literal> 8 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 16) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 16 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 14 could run on GPU\n",
      "                        @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                          @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) could run on GPU\n",
      "                            @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 24) could run on GPU\n",
      "                              @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                  @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                            @Expression <Literal> 255 could run on GPU\n",
      "                          @Expression <Literal> 10 could run on GPU\n",
      "                      @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                        @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) could run on GPU\n",
      "                          @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 32) could run on GPU\n",
      "                            @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                              ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                            @Expression <Literal> 32 could run on GPU\n",
      "                          @Expression <Literal> 255 could run on GPU\n",
      "                        @Expression <Literal> 6 could run on GPU\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "\n",
      "2022-04-05 09:36:37,176 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#816 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> kind#133 could run on GPU\n",
      "  @Expression <AttributeReference> value#136 could run on GPU\n",
      "  @Expression <AttributeReference> date#156 could run on GPU\n",
      "  @Expression <AttributeReference> month#315 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <Alias> Charge AS kind#133 could run on GPU\n",
      "            @Expression <Literal> Charge could run on GPU\n",
      "          @Expression <AttributeReference> value#136 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) AS date#156 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              @Expression <Cast> cast(-(cast(_we0#149 as bigint) + last_month#135L) as int) could run on GPU\n",
      "                @Expression <UnaryMinus> -(cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                  @Expression <Add> (cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                    @Expression <Cast> cast(_we0#149 as bigint) could run on GPU\n",
      "                      @Expression <AttributeReference> _we0#149 could run on GPU\n",
      "                    @Expression <AttributeReference> last_month#135L could run on GPU\n",
      "              !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "                @Partitioning <HashPartitioning> could run on GPU\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                  @Expression <AttributeReference> value#136 could run on GPU\n",
      "                  @Expression <Alias> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END AS last_month#135L could run on GPU\n",
      "                    @Expression <CaseWhen> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END could run on GPU\n",
      "                      @Expression <EqualTo> (Churn#20 = Yes) could run on GPU\n",
      "                        @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                        @Expression <Literal> Yes could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#0, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#0, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                      @Expression <Literal> 0 could run on GPU\n",
      "                  !Exec <GenerateExec> cannot run on GPU because not all expressions can be replaced\n",
      "                    @Expression <Explode> explode(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                      ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                        @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                          @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                            @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                            @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                        !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                          @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                    @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                      !Exec <FilterExec> cannot run on GPU because not all expressions can be replaced\n",
      "                        @Expression <And> ((atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) AND isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)))) could run on GPU\n",
      "                          @Expression <And> (atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) could run on GPU\n",
      "                            @Expression <AtLeastNNonNulls> atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) could run on GPU\n",
      "                              @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                              @Expression <AttributeReference> gender#1 could run on GPU\n",
      "                              @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                              @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "                              @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "                              @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <AttributeReference> PhoneService#6 could run on GPU\n",
      "                              @Expression <AttributeReference> MultipleLines#7 could run on GPU\n",
      "                              @Expression <AttributeReference> InternetService#8 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineSecurity#9 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineBackup#10 could run on GPU\n",
      "                              @Expression <AttributeReference> DeviceProtection#11 could run on GPU\n",
      "                              @Expression <AttributeReference> TechSupport#12 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingTV#13 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingMovies#14 could run on GPU\n",
      "                              @Expression <AttributeReference> Contract#15 could run on GPU\n",
      "                              @Expression <AttributeReference> PaperlessBilling#16 could run on GPU\n",
      "                              @Expression <AttributeReference> PaymentMethod#17 could run on GPU\n",
      "                              @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "                              @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                              @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                            @Expression <GreaterThan> (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0) could run on GPU\n",
      "                              @Expression <Size> size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) could run on GPU\n",
      "                                ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                                  @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                    @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                      @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                      @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                                  !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                    @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <Literal> 0 could run on GPU\n",
      "                          @Expression <IsNotNull> isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                            ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                              @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                  @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                  @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "          @Expression <Alias> AccountCreation AS kind#191 could run on GPU\n",
      "            @Expression <Literal> AccountCreation could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#192 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) AS date#200 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              !Expression <Cast> cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                @Expression <Add> ((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) could run on GPU\n",
      "                  @Expression <Subtract> (-tenure#270 - 1.0) could run on GPU\n",
      "                    @Expression <UnaryMinus> -tenure#270 could run on GPU\n",
      "                      @Expression <AttributeReference> tenure#270 could run on GPU\n",
      "                    @Expression <Literal> 1.0 could run on GPU\n",
      "                  @Expression <CaseWhen> CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END could run on GPU\n",
      "                    @Expression <EqualTo> (Churn#285 = Yes) could run on GPU\n",
      "                      @Expression <AttributeReference> Churn#285 could run on GPU\n",
      "                      @Expression <Literal> Yes could run on GPU\n",
      "                    @Expression <Cast> cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#265, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#265, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                    @Expression <Literal> 0.0 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "          @Expression <Alias> AccountTermination AS kind#258 could run on GPU\n",
      "            @Expression <Literal> AccountTermination could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#259 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END AS date#260 could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END could run on GPU\n",
      "              @Expression <EqualTo> (Churn#310 = Yes) could run on GPU\n",
      "                @Expression <AttributeReference> Churn#310 could run on GPU\n",
      "                @Expression <Literal> Yes could run on GPU\n",
      "              ! <AddMonths> add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "                @Expression <Literal> 2022-04-05 could run on GPU\n",
      "                @Expression <Cast> cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int) could run on GPU\n",
      "                  @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                    @Expression <Add> ((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                      @Expression <Add> (((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                        @Expression <Add> ((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                          @Expression <Add> (((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                            @Expression <Remainder> ((abs(xxhash64(customerID#290, 42), false) & 255) % 36) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (abs(xxhash64(customerID#290, 42), false) & 255) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 36 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 8) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                  @Expression <Literal> 8 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 16) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 16 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 14 could run on GPU\n",
      "                        @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                          @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) could run on GPU\n",
      "                            @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 24) could run on GPU\n",
      "                              @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                  @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                            @Expression <Literal> 255 could run on GPU\n",
      "                          @Expression <Literal> 10 could run on GPU\n",
      "                      @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                        @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) could run on GPU\n",
      "                          @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 32) could run on GPU\n",
      "                            @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                              ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                            @Expression <Literal> 32 could run on GPU\n",
      "                          @Expression <Literal> 255 could run on GPU\n",
      "                        @Expression <Literal> 6 could run on GPU\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "\n",
      "2022-04-05 09:36:37,199 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#816 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> kind#133 could run on GPU\n",
      "  @Expression <AttributeReference> value#136 could run on GPU\n",
      "  @Expression <AttributeReference> date#156 could run on GPU\n",
      "  @Expression <AttributeReference> month#315 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <Alias> Charge AS kind#133 could run on GPU\n",
      "            @Expression <Literal> Charge could run on GPU\n",
      "          @Expression <AttributeReference> value#136 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) AS date#156 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              @Expression <Cast> cast(-(cast(_we0#149 as bigint) + last_month#135L) as int) could run on GPU\n",
      "                @Expression <UnaryMinus> -(cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                  @Expression <Add> (cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                    @Expression <Cast> cast(_we0#149 as bigint) could run on GPU\n",
      "                      @Expression <AttributeReference> _we0#149 could run on GPU\n",
      "                    @Expression <AttributeReference> last_month#135L could run on GPU\n",
      "              !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "                @Partitioning <HashPartitioning> could run on GPU\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                  @Expression <AttributeReference> value#136 could run on GPU\n",
      "                  @Expression <Alias> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END AS last_month#135L could run on GPU\n",
      "                    @Expression <CaseWhen> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END could run on GPU\n",
      "                      @Expression <EqualTo> (Churn#20 = Yes) could run on GPU\n",
      "                        @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                        @Expression <Literal> Yes could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#0, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#0, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                      @Expression <Literal> 0 could run on GPU\n",
      "                  !Exec <GenerateExec> cannot run on GPU because not all expressions can be replaced\n",
      "                    @Expression <Explode> explode(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                      ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                        @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                          @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                            @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                            @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                        !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                          @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                    @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                      !Exec <FilterExec> cannot run on GPU because not all expressions can be replaced\n",
      "                        @Expression <And> ((atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) AND isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)))) could run on GPU\n",
      "                          @Expression <And> (atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) could run on GPU\n",
      "                            @Expression <AtLeastNNonNulls> atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) could run on GPU\n",
      "                              @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                              @Expression <AttributeReference> gender#1 could run on GPU\n",
      "                              @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                              @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "                              @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "                              @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <AttributeReference> PhoneService#6 could run on GPU\n",
      "                              @Expression <AttributeReference> MultipleLines#7 could run on GPU\n",
      "                              @Expression <AttributeReference> InternetService#8 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineSecurity#9 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineBackup#10 could run on GPU\n",
      "                              @Expression <AttributeReference> DeviceProtection#11 could run on GPU\n",
      "                              @Expression <AttributeReference> TechSupport#12 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingTV#13 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingMovies#14 could run on GPU\n",
      "                              @Expression <AttributeReference> Contract#15 could run on GPU\n",
      "                              @Expression <AttributeReference> PaperlessBilling#16 could run on GPU\n",
      "                              @Expression <AttributeReference> PaymentMethod#17 could run on GPU\n",
      "                              @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "                              @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                              @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                            @Expression <GreaterThan> (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0) could run on GPU\n",
      "                              @Expression <Size> size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) could run on GPU\n",
      "                                ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                                  @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                    @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                      @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                      @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                                  !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                    @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <Literal> 0 could run on GPU\n",
      "                          @Expression <IsNotNull> isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                            ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                              @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                  @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                  @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "          @Expression <Alias> AccountCreation AS kind#191 could run on GPU\n",
      "            @Expression <Literal> AccountCreation could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#192 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) AS date#200 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              !Expression <Cast> cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                @Expression <Add> ((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) could run on GPU\n",
      "                  @Expression <Subtract> (-tenure#270 - 1.0) could run on GPU\n",
      "                    @Expression <UnaryMinus> -tenure#270 could run on GPU\n",
      "                      @Expression <AttributeReference> tenure#270 could run on GPU\n",
      "                    @Expression <Literal> 1.0 could run on GPU\n",
      "                  @Expression <CaseWhen> CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END could run on GPU\n",
      "                    @Expression <EqualTo> (Churn#285 = Yes) could run on GPU\n",
      "                      @Expression <AttributeReference> Churn#285 could run on GPU\n",
      "                      @Expression <Literal> Yes could run on GPU\n",
      "                    @Expression <Cast> cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#265, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#265, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                    @Expression <Literal> 0.0 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "          @Expression <Alias> AccountTermination AS kind#258 could run on GPU\n",
      "            @Expression <Literal> AccountTermination could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#259 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END AS date#260 could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END could run on GPU\n",
      "              @Expression <EqualTo> (Churn#310 = Yes) could run on GPU\n",
      "                @Expression <AttributeReference> Churn#310 could run on GPU\n",
      "                @Expression <Literal> Yes could run on GPU\n",
      "              ! <AddMonths> add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "                @Expression <Literal> 2022-04-05 could run on GPU\n",
      "                @Expression <Cast> cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int) could run on GPU\n",
      "                  @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                    @Expression <Add> ((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                      @Expression <Add> (((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                        @Expression <Add> ((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                          @Expression <Add> (((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                            @Expression <Remainder> ((abs(xxhash64(customerID#290, 42), false) & 255) % 36) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (abs(xxhash64(customerID#290, 42), false) & 255) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 36 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 8) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                  @Expression <Literal> 8 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 16) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 16 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 14 could run on GPU\n",
      "                        @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                          @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) could run on GPU\n",
      "                            @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 24) could run on GPU\n",
      "                              @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                  @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                            @Expression <Literal> 255 could run on GPU\n",
      "                          @Expression <Literal> 10 could run on GPU\n",
      "                      @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                        @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) could run on GPU\n",
      "                          @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 32) could run on GPU\n",
      "                            @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                              ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                            @Expression <Literal> 32 could run on GPU\n",
      "                          @Expression <Literal> 255 could run on GPU\n",
      "                        @Expression <Literal> 6 could run on GPU\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "\n",
      "2022-04-05 09:36:37,210 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#816 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> kind#133 could run on GPU\n",
      "  @Expression <AttributeReference> value#136 could run on GPU\n",
      "  @Expression <AttributeReference> date#156 could run on GPU\n",
      "  @Expression <AttributeReference> month#315 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <Alias> Charge AS kind#133 could run on GPU\n",
      "            @Expression <Literal> Charge could run on GPU\n",
      "          @Expression <AttributeReference> value#136 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) AS date#156 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              @Expression <Cast> cast(-(cast(_we0#149 as bigint) + last_month#135L) as int) could run on GPU\n",
      "                @Expression <UnaryMinus> -(cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                  @Expression <Add> (cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                    @Expression <Cast> cast(_we0#149 as bigint) could run on GPU\n",
      "                      @Expression <AttributeReference> _we0#149 could run on GPU\n",
      "                    @Expression <AttributeReference> last_month#135L could run on GPU\n",
      "              !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "                @Partitioning <HashPartitioning> could run on GPU\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "                  @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                  @Expression <AttributeReference> value#136 could run on GPU\n",
      "                  @Expression <Alias> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END AS last_month#135L could run on GPU\n",
      "                    @Expression <CaseWhen> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END could run on GPU\n",
      "                      @Expression <EqualTo> (Churn#20 = Yes) could run on GPU\n",
      "                        @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                        @Expression <Literal> Yes could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#0, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#0, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                      @Expression <Literal> 0 could run on GPU\n",
      "                  !Exec <GenerateExec> cannot run on GPU because not all expressions can be replaced\n",
      "                    @Expression <Explode> explode(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                      ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                        @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                          @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                            @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                            @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                        !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                          @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                    @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                      !Exec <FilterExec> cannot run on GPU because not all expressions can be replaced\n",
      "                        @Expression <And> ((atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) AND isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)))) could run on GPU\n",
      "                          @Expression <And> (atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) could run on GPU\n",
      "                            @Expression <AtLeastNNonNulls> atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) could run on GPU\n",
      "                              @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                              @Expression <AttributeReference> gender#1 could run on GPU\n",
      "                              @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                              @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "                              @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "                              @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <AttributeReference> PhoneService#6 could run on GPU\n",
      "                              @Expression <AttributeReference> MultipleLines#7 could run on GPU\n",
      "                              @Expression <AttributeReference> InternetService#8 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineSecurity#9 could run on GPU\n",
      "                              @Expression <AttributeReference> OnlineBackup#10 could run on GPU\n",
      "                              @Expression <AttributeReference> DeviceProtection#11 could run on GPU\n",
      "                              @Expression <AttributeReference> TechSupport#12 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingTV#13 could run on GPU\n",
      "                              @Expression <AttributeReference> StreamingMovies#14 could run on GPU\n",
      "                              @Expression <AttributeReference> Contract#15 could run on GPU\n",
      "                              @Expression <AttributeReference> PaperlessBilling#16 could run on GPU\n",
      "                              @Expression <AttributeReference> PaymentMethod#17 could run on GPU\n",
      "                              @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "                              @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                              @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "                            @Expression <GreaterThan> (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0) could run on GPU\n",
      "                              @Expression <Size> size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) could run on GPU\n",
      "                                ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                                  @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                    @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                      @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                      @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                                  !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                    @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              @Expression <Literal> 0 could run on GPU\n",
      "                          @Expression <IsNotNull> isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "                            ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                              @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                                @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                                  @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                                  @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                              !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                                @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "          @Expression <Alias> AccountCreation AS kind#191 could run on GPU\n",
      "            @Expression <Literal> AccountCreation could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#192 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) AS date#200 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              !Expression <Cast> cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                @Expression <Add> ((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) could run on GPU\n",
      "                  @Expression <Subtract> (-tenure#270 - 1.0) could run on GPU\n",
      "                    @Expression <UnaryMinus> -tenure#270 could run on GPU\n",
      "                      @Expression <AttributeReference> tenure#270 could run on GPU\n",
      "                    @Expression <Literal> 1.0 could run on GPU\n",
      "                  @Expression <CaseWhen> CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END could run on GPU\n",
      "                    @Expression <EqualTo> (Churn#285 = Yes) could run on GPU\n",
      "                      @Expression <AttributeReference> Churn#285 could run on GPU\n",
      "                      @Expression <Literal> Yes could run on GPU\n",
      "                    @Expression <Cast> cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#265, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#265, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                    @Expression <Literal> 0.0 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "          @Expression <Alias> AccountTermination AS kind#258 could run on GPU\n",
      "            @Expression <Literal> AccountTermination could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#259 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END AS date#260 could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END could run on GPU\n",
      "              @Expression <EqualTo> (Churn#310 = Yes) could run on GPU\n",
      "                @Expression <AttributeReference> Churn#310 could run on GPU\n",
      "                @Expression <Literal> Yes could run on GPU\n",
      "              ! <AddMonths> add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "                @Expression <Literal> 2022-04-05 could run on GPU\n",
      "                @Expression <Cast> cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int) could run on GPU\n",
      "                  @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                    @Expression <Add> ((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                      @Expression <Add> (((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                        @Expression <Add> ((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                          @Expression <Add> (((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                            @Expression <Remainder> ((abs(xxhash64(customerID#290, 42), false) & 255) % 36) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (abs(xxhash64(customerID#290, 42), false) & 255) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 36 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 8) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                  @Expression <Literal> 8 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 16) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 16 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 14 could run on GPU\n",
      "                        @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                          @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) could run on GPU\n",
      "                            @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 24) could run on GPU\n",
      "                              @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                  @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                            @Expression <Literal> 255 could run on GPU\n",
      "                          @Expression <Literal> 10 could run on GPU\n",
      "                      @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                        @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) could run on GPU\n",
      "                          @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 32) could run on GPU\n",
      "                            @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                              ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                            @Expression <Literal> 32 could run on GPU\n",
      "                          @Expression <Literal> 255 could run on GPU\n",
      "                        @Expression <Literal> 6 could run on GPU\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "\n",
      "2022-04-05 09:36:37,305 WARN rapids.GpuOverrides: \n",
      "!Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "  @Partitioning <HashPartitioning> could run on GPU\n",
      "    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "  !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "    @Expression <AttributeReference> value#136 could run on GPU\n",
      "    @Expression <Alias> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END AS last_month#135L could run on GPU\n",
      "      @Expression <CaseWhen> CASE WHEN (Churn#20 = Yes) THEN -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) ELSE 0 END could run on GPU\n",
      "        @Expression <EqualTo> (Churn#20 = Yes) could run on GPU\n",
      "          @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "          @Expression <Literal> Yes could run on GPU\n",
      "        @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "          @Expression <Add> ((((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "            @Expression <Add> (((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "              @Expression <Add> ((((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                @Expression <Add> (((abs(xxhash64(customerID#0, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                  @Expression <Remainder> ((abs(xxhash64(customerID#0, 42), false) & 255) % 36) could run on GPU\n",
      "                    @Expression <BitwiseAnd> (abs(xxhash64(customerID#0, 42), false) & 255) could run on GPU\n",
      "                      @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                        ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                      @Expression <Literal> 255 could run on GPU\n",
      "                    @Expression <Literal> 36 could run on GPU\n",
      "                  @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                    @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 8) & 255) could run on GPU\n",
      "                      @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 8) could run on GPU\n",
      "                        @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                          ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                            @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                        @Expression <Literal> 8 could run on GPU\n",
      "                      @Expression <Literal> 255 could run on GPU\n",
      "                    @Expression <Literal> 24 could run on GPU\n",
      "                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 16) & 255) could run on GPU\n",
      "                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 16) could run on GPU\n",
      "                      @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                        ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                      @Expression <Literal> 16 could run on GPU\n",
      "                    @Expression <Literal> 255 could run on GPU\n",
      "                  @Expression <Literal> 14 could run on GPU\n",
      "              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 24) & 255) could run on GPU\n",
      "                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 24) could run on GPU\n",
      "                    @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                      ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                    @Expression <Literal> 24 could run on GPU\n",
      "                  @Expression <Literal> 255 could run on GPU\n",
      "                @Expression <Literal> 10 could run on GPU\n",
      "            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) % 6) could run on GPU\n",
      "              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#0, 42), false), 32) & 255) could run on GPU\n",
      "                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#0, 42), false), 32) could run on GPU\n",
      "                  @Expression <Abs> abs(xxhash64(customerID#0, 42), false) could run on GPU\n",
      "                    ! <XxHash64> xxhash64(customerID#0, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                  @Expression <Literal> 32 could run on GPU\n",
      "                @Expression <Literal> 255 could run on GPU\n",
      "              @Expression <Literal> 6 could run on GPU\n",
      "        @Expression <Literal> 0 could run on GPU\n",
      "    !Exec <GenerateExec> cannot run on GPU because not all expressions can be replaced\n",
      "      @Expression <Explode> explode(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "        ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "          @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "            @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "              @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "              @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "          !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "            @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "        !Exec <FilterExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <And> ((atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) AND isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)))) could run on GPU\n",
      "            @Expression <And> (atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) AND (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0)) could run on GPU\n",
      "              @Expression <AtLeastNNonNulls> atleastnnonnulls(21, customerID#0, gender#1, SeniorCitizen#2, Partner#3, Dependents#4, tenure#5, PhoneService#6, MultipleLines#7, InternetService#8, OnlineSecurity#9, OnlineBackup#10, DeviceProtection#11, TechSupport#12, StreamingTV#13, StreamingMovies#14, Contract#15, PaperlessBilling#16, PaymentMethod#17, MonthlyCharges#18, TotalCharges#19, Churn#20) could run on GPU\n",
      "                @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                @Expression <AttributeReference> gender#1 could run on GPU\n",
      "                @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "                @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "                @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                @Expression <AttributeReference> PhoneService#6 could run on GPU\n",
      "                @Expression <AttributeReference> MultipleLines#7 could run on GPU\n",
      "                @Expression <AttributeReference> InternetService#8 could run on GPU\n",
      "                @Expression <AttributeReference> OnlineSecurity#9 could run on GPU\n",
      "                @Expression <AttributeReference> OnlineBackup#10 could run on GPU\n",
      "                @Expression <AttributeReference> DeviceProtection#11 could run on GPU\n",
      "                @Expression <AttributeReference> TechSupport#12 could run on GPU\n",
      "                @Expression <AttributeReference> StreamingTV#13 could run on GPU\n",
      "                @Expression <AttributeReference> StreamingMovies#14 could run on GPU\n",
      "                @Expression <AttributeReference> Contract#15 could run on GPU\n",
      "                @Expression <AttributeReference> PaperlessBilling#16 could run on GPU\n",
      "                @Expression <AttributeReference> PaymentMethod#17 could run on GPU\n",
      "                @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "                @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                @Expression <AttributeReference> Churn#20 could run on GPU\n",
      "              @Expression <GreaterThan> (size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) > 0) could run on GPU\n",
      "                @Expression <Size> size(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)), true) could run on GPU\n",
      "                  ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                    @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                      @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                        @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                        @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                    !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                      @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                @Expression <Literal> 0 could run on GPU\n",
      "            @Expression <IsNotNull> isnotnull(array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int))) could run on GPU\n",
      "              ! <ArrayRepeat> array_repeat(cast((TotalCharges#19 / tenure#5) as decimal(8,2)), cast(tenure#5 as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.ArrayRepeat\n",
      "                @Expression <Cast> cast((TotalCharges#19 / tenure#5) as decimal(8,2)) could run on GPU\n",
      "                  @Expression <Divide> (TotalCharges#19 / tenure#5) could run on GPU\n",
      "                    @Expression <AttributeReference> TotalCharges#19 could run on GPU\n",
      "                    @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "                !Expression <Cast> cast(tenure#5 as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                  @Expression <AttributeReference> tenure#5 could run on GPU\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:36:37,476 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#816 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> kind#133 could run on GPU\n",
      "  @Expression <AttributeReference> value#136 could run on GPU\n",
      "  @Expression <AttributeReference> date#156 could run on GPU\n",
      "  @Expression <AttributeReference> month#315 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <Alias> Charge AS kind#133 could run on GPU\n",
      "            @Expression <Literal> Charge could run on GPU\n",
      "          @Expression <AttributeReference> value#136 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) AS date#156 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              @Expression <Cast> cast(-(cast(_we0#149 as bigint) + last_month#135L) as int) could run on GPU\n",
      "                @Expression <UnaryMinus> -(cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                  @Expression <Add> (cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                    @Expression <Cast> cast(_we0#149 as bigint) could run on GPU\n",
      "                      @Expression <AttributeReference> _we0#149 could run on GPU\n",
      "                    @Expression <AttributeReference> last_month#135L could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "          @Expression <Alias> AccountCreation AS kind#191 could run on GPU\n",
      "            @Expression <Literal> AccountCreation could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#192 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) AS date#200 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              !Expression <Cast> cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                @Expression <Add> ((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) could run on GPU\n",
      "                  @Expression <Subtract> (-tenure#270 - 1.0) could run on GPU\n",
      "                    @Expression <UnaryMinus> -tenure#270 could run on GPU\n",
      "                      @Expression <AttributeReference> tenure#270 could run on GPU\n",
      "                    @Expression <Literal> 1.0 could run on GPU\n",
      "                  @Expression <CaseWhen> CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END could run on GPU\n",
      "                    @Expression <EqualTo> (Churn#285 = Yes) could run on GPU\n",
      "                      @Expression <AttributeReference> Churn#285 could run on GPU\n",
      "                      @Expression <Literal> Yes could run on GPU\n",
      "                    @Expression <Cast> cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#265, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#265, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                    @Expression <Literal> 0.0 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "          @Expression <Alias> AccountTermination AS kind#258 could run on GPU\n",
      "            @Expression <Literal> AccountTermination could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#259 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END AS date#260 could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END could run on GPU\n",
      "              @Expression <EqualTo> (Churn#310 = Yes) could run on GPU\n",
      "                @Expression <AttributeReference> Churn#310 could run on GPU\n",
      "                @Expression <Literal> Yes could run on GPU\n",
      "              ! <AddMonths> add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "                @Expression <Literal> 2022-04-05 could run on GPU\n",
      "                @Expression <Cast> cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int) could run on GPU\n",
      "                  @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                    @Expression <Add> ((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                      @Expression <Add> (((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                        @Expression <Add> ((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                          @Expression <Add> (((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                            @Expression <Remainder> ((abs(xxhash64(customerID#290, 42), false) & 255) % 36) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (abs(xxhash64(customerID#290, 42), false) & 255) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 36 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 8) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                  @Expression <Literal> 8 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 16) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 16 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 14 could run on GPU\n",
      "                        @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                          @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) could run on GPU\n",
      "                            @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 24) could run on GPU\n",
      "                              @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                  @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                            @Expression <Literal> 255 could run on GPU\n",
      "                          @Expression <Literal> 10 could run on GPU\n",
      "                      @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                        @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) could run on GPU\n",
      "                          @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 32) could run on GPU\n",
      "                            @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                              ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                            @Expression <Literal> 32 could run on GPU\n",
      "                          @Expression <Literal> 255 could run on GPU\n",
      "                        @Expression <Literal> 6 could run on GPU\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:36:37,897 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#816 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> kind#133 could run on GPU\n",
      "  @Expression <AttributeReference> value#136 could run on GPU\n",
      "  @Expression <AttributeReference> date#156 could run on GPU\n",
      "  @Expression <AttributeReference> month#315 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <Alias> Charge AS kind#133 could run on GPU\n",
      "            @Expression <Literal> Charge could run on GPU\n",
      "          @Expression <AttributeReference> value#136 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) AS date#156 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              @Expression <Cast> cast(-(cast(_we0#149 as bigint) + last_month#135L) as int) could run on GPU\n",
      "                @Expression <UnaryMinus> -(cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                  @Expression <Add> (cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                    @Expression <Cast> cast(_we0#149 as bigint) could run on GPU\n",
      "                      @Expression <AttributeReference> _we0#149 could run on GPU\n",
      "                    @Expression <AttributeReference> last_month#135L could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "          @Expression <Alias> AccountCreation AS kind#191 could run on GPU\n",
      "            @Expression <Literal> AccountCreation could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#192 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) AS date#200 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              !Expression <Cast> cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                @Expression <Add> ((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) could run on GPU\n",
      "                  @Expression <Subtract> (-tenure#270 - 1.0) could run on GPU\n",
      "                    @Expression <UnaryMinus> -tenure#270 could run on GPU\n",
      "                      @Expression <AttributeReference> tenure#270 could run on GPU\n",
      "                    @Expression <Literal> 1.0 could run on GPU\n",
      "                  @Expression <CaseWhen> CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END could run on GPU\n",
      "                    @Expression <EqualTo> (Churn#285 = Yes) could run on GPU\n",
      "                      @Expression <AttributeReference> Churn#285 could run on GPU\n",
      "                      @Expression <Literal> Yes could run on GPU\n",
      "                    @Expression <Cast> cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#265, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#265, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                    @Expression <Literal> 0.0 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "          @Expression <Alias> AccountTermination AS kind#258 could run on GPU\n",
      "            @Expression <Literal> AccountTermination could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#259 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END AS date#260 could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END could run on GPU\n",
      "              @Expression <EqualTo> (Churn#310 = Yes) could run on GPU\n",
      "                @Expression <AttributeReference> Churn#310 could run on GPU\n",
      "                @Expression <Literal> Yes could run on GPU\n",
      "              ! <AddMonths> add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "                @Expression <Literal> 2022-04-05 could run on GPU\n",
      "                @Expression <Cast> cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int) could run on GPU\n",
      "                  @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                    @Expression <Add> ((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                      @Expression <Add> (((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                        @Expression <Add> ((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                          @Expression <Add> (((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                            @Expression <Remainder> ((abs(xxhash64(customerID#290, 42), false) & 255) % 36) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (abs(xxhash64(customerID#290, 42), false) & 255) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 36 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 8) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                  @Expression <Literal> 8 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 16) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 16 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 14 could run on GPU\n",
      "                        @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                          @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) could run on GPU\n",
      "                            @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 24) could run on GPU\n",
      "                              @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                  @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                            @Expression <Literal> 255 could run on GPU\n",
      "                          @Expression <Literal> 10 could run on GPU\n",
      "                      @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                        @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) could run on GPU\n",
      "                          @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 32) could run on GPU\n",
      "                            @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                              ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                            @Expression <Literal> 32 could run on GPU\n",
      "                          @Expression <Literal> 255 could run on GPU\n",
      "                        @Expression <Literal> 6 could run on GPU\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "\n",
      "2022-04-05 09:36:37,903 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#816 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> kind#133 could run on GPU\n",
      "  @Expression <AttributeReference> value#136 could run on GPU\n",
      "  @Expression <AttributeReference> date#156 could run on GPU\n",
      "  @Expression <AttributeReference> month#315 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <Alias> Charge AS kind#133 could run on GPU\n",
      "            @Expression <Literal> Charge could run on GPU\n",
      "          @Expression <AttributeReference> value#136 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) AS date#156 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(-(cast(_we0#149 as bigint) + last_month#135L) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              @Expression <Cast> cast(-(cast(_we0#149 as bigint) + last_month#135L) as int) could run on GPU\n",
      "                @Expression <UnaryMinus> -(cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                  @Expression <Add> (cast(_we0#149 as bigint) + last_month#135L) could run on GPU\n",
      "                    @Expression <Cast> cast(_we0#149 as bigint) could run on GPU\n",
      "                      @Expression <AttributeReference> _we0#149 could run on GPU\n",
      "                    @Expression <AttributeReference> last_month#135L could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "          @Expression <Alias> AccountCreation AS kind#191 could run on GPU\n",
      "            @Expression <Literal> AccountCreation could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#192 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) AS date#200 could run on GPU\n",
      "            ! <AddMonths> add_months(2022-04-05, cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "              !Expression <Cast> cast(((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) as int) cannot run on GPU because Casting from floating point types to integral types on the GPU supports a slightly different range of values when using Spark 3.1.0 or later. Refer to the CAST documentation for more details.. To enable this operation on the GPU, set spark.rapids.sql.castFloatToIntegralTypes.enabled to true.\n",
      "                @Expression <Add> ((-tenure#270 - 1.0) + CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END) could run on GPU\n",
      "                  @Expression <Subtract> (-tenure#270 - 1.0) could run on GPU\n",
      "                    @Expression <UnaryMinus> -tenure#270 could run on GPU\n",
      "                      @Expression <AttributeReference> tenure#270 could run on GPU\n",
      "                    @Expression <Literal> 1.0 could run on GPU\n",
      "                  @Expression <CaseWhen> CASE WHEN (Churn#285 = Yes) THEN cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) ELSE 0.0 END could run on GPU\n",
      "                    @Expression <EqualTo> (Churn#285 = Yes) could run on GPU\n",
      "                      @Expression <AttributeReference> Churn#285 could run on GPU\n",
      "                      @Expression <Literal> Yes could run on GPU\n",
      "                    @Expression <Cast> cast(-((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) as double) could run on GPU\n",
      "                      @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                        @Expression <Add> ((((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                          @Expression <Add> (((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                            @Expression <Add> ((((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                              @Expression <Add> (((abs(xxhash64(customerID#265, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                                @Expression <Remainder> ((abs(xxhash64(customerID#265, 42), false) & 255) % 36) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (abs(xxhash64(customerID#265, 42), false) & 255) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 36 could run on GPU\n",
      "                                @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                                  @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 8) & 255) could run on GPU\n",
      "                                    @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 8) could run on GPU\n",
      "                                      @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                        ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                          @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                      @Expression <Literal> 8 could run on GPU\n",
      "                                    @Expression <Literal> 255 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                              @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                                @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 16) & 255) could run on GPU\n",
      "                                  @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 16) could run on GPU\n",
      "                                    @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                      ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                        @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                    @Expression <Literal> 16 could run on GPU\n",
      "                                  @Expression <Literal> 255 could run on GPU\n",
      "                                @Expression <Literal> 14 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 24) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 24) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                  @Expression <Literal> 24 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 10 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#265, 42), false), 32) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#265, 42), false), 32) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#265, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#265, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#265 could run on GPU\n",
      "                                @Expression <Literal> 32 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 6 could run on GPU\n",
      "                    @Expression <Literal> 0.0 could run on GPU\n",
      "        !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "          @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "          @Expression <Alias> AccountTermination AS kind#258 could run on GPU\n",
      "            @Expression <Literal> AccountTermination could run on GPU\n",
      "          @Expression <Alias> 0.00 AS value#259 could run on GPU\n",
      "            @Expression <Literal> 0.00 could run on GPU\n",
      "          @Expression <Alias> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END AS date#260 could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (Churn#310 = Yes) THEN add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) ELSE 2022-04-05 END could run on GPU\n",
      "              @Expression <EqualTo> (Churn#310 = Yes) could run on GPU\n",
      "                @Expression <AttributeReference> Churn#310 could run on GPU\n",
      "                @Expression <Literal> Yes could run on GPU\n",
      "              ! <AddMonths> add_months(2022-04-05, cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int)) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.AddMonths\n",
      "                @Expression <Literal> 2022-04-05 could run on GPU\n",
      "                @Expression <Cast> cast(-((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) as int) could run on GPU\n",
      "                  @Expression <UnaryMinus> -((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                    @Expression <Add> ((((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6)) could run on GPU\n",
      "                      @Expression <Add> (((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10)) could run on GPU\n",
      "                        @Expression <Add> ((((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14)) could run on GPU\n",
      "                          @Expression <Add> (((abs(xxhash64(customerID#290, 42), false) & 255) % 36) + ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24)) could run on GPU\n",
      "                            @Expression <Remainder> ((abs(xxhash64(customerID#290, 42), false) & 255) % 36) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (abs(xxhash64(customerID#290, 42), false) & 255) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 36 could run on GPU\n",
      "                            @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) % 24) could run on GPU\n",
      "                              @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 8) & 255) could run on GPU\n",
      "                                @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 8) could run on GPU\n",
      "                                  @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                    ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                      @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                  @Expression <Literal> 8 could run on GPU\n",
      "                                @Expression <Literal> 255 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                          @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) % 14) could run on GPU\n",
      "                            @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 16) & 255) could run on GPU\n",
      "                              @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 16) could run on GPU\n",
      "                                @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                  ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                    @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                                @Expression <Literal> 16 could run on GPU\n",
      "                              @Expression <Literal> 255 could run on GPU\n",
      "                            @Expression <Literal> 14 could run on GPU\n",
      "                        @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) % 10) could run on GPU\n",
      "                          @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 24) & 255) could run on GPU\n",
      "                            @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 24) could run on GPU\n",
      "                              @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                                ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                  @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                              @Expression <Literal> 24 could run on GPU\n",
      "                            @Expression <Literal> 255 could run on GPU\n",
      "                          @Expression <Literal> 10 could run on GPU\n",
      "                      @Expression <Remainder> ((shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) % 6) could run on GPU\n",
      "                        @Expression <BitwiseAnd> (shiftright(abs(xxhash64(customerID#290, 42), false), 32) & 255) could run on GPU\n",
      "                          @Expression <ShiftRight> shiftright(abs(xxhash64(customerID#290, 42), false), 32) could run on GPU\n",
      "                            @Expression <Abs> abs(xxhash64(customerID#290, 42), false) could run on GPU\n",
      "                              ! <XxHash64> xxhash64(customerID#290, 42) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.XxHash64\n",
      "                                @Expression <AttributeReference> customerID#290 could run on GPU\n",
      "                            @Expression <Literal> 32 could run on GPU\n",
      "                          @Expression <Literal> 255 could run on GPU\n",
      "                        @Expression <Literal> 6 could run on GPU\n",
      "              @Expression <Literal> 2022-04-05 could run on GPU\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:40:21,129 WARN rapids.GpuOverrides:                               \n",
      "  !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "    @Partitioning <RangePartitioning> could run on GPU\n",
      "      @Expression <SortOrder> customerID#395 ASC NULLS FIRST could run on GPU\n",
      "        @Expression <AttributeReference> customerID#395 could run on GPU\n",
      "    !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "      @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#395 could run on GPU\n",
      "        ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "          @Expression <Literal> %s-%s could run on GPU\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "      @Expression <Alias> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) AS dateOfBirth#460 could run on GPU\n",
      "        @Expression <DateSub> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) could run on GPU\n",
      "          @Expression <Literal> 2022-04-05 could run on GPU\n",
      "          @Expression <Cast> cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int) could run on GPU\n",
      "            @Expression <Floor> FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) could run on GPU\n",
      "              @Expression <CaseWhen> CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END could run on GPU\n",
      "                @Expression <EqualTo> (cast(SeniorCitizen#2 as int) = 0) could run on GPU\n",
      "                  @Expression <Cast> cast(SeniorCitizen#2 as int) could run on GPU\n",
      "                    @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                  @Expression <Literal> 0 could run on GPU\n",
      "                @Expression <Add> (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) could run on GPU\n",
      "                  @Expression <Multiply> ((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) could run on GPU\n",
      "                    @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                      @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                        @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                          @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                            @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                              ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                @Expression <Literal> %s-%s could run on GPU\n",
      "                                @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                          @Expression <Literal> 4096 could run on GPU\n",
      "                      @Expression <Literal> 4096.0 could run on GPU\n",
      "                    @Expression <Literal> 16801.5 could run on GPU\n",
      "                  @Expression <Literal> 6574.5 could run on GPU\n",
      "                @Expression <Add> (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) could run on GPU\n",
      "                  @Expression <Multiply> ((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) could run on GPU\n",
      "                    @Expression <Multiply> (-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) could run on GPU\n",
      "                      @Expression <UnaryMinus> -LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                        @Expression <Log1p> LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                          @Expression <UnaryMinus> -(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                            @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                              @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                                @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                                  @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                                    @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                                      ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                        @Expression <Literal> %s-%s could run on GPU\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                        @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                                  @Expression <Literal> 4096 could run on GPU\n",
      "                              @Expression <Literal> 4096.0 could run on GPU\n",
      "                      @Expression <Literal> 6.3 could run on GPU\n",
      "                    @Expression <Literal> 365.25 could run on GPU\n",
      "                  @Expression <Literal> 23741.25 could run on GPU\n",
      "      @Expression <AttributeReference> gender#1 could run on GPU\n",
      "      @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "      @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "      @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "      @Expression <Alias> cast(MonthlyCharges#18 as decimal(8,2)) AS MonthlyCharges#441 could run on GPU\n",
      "        @Expression <Cast> cast(MonthlyCharges#18 as decimal(8,2)) could run on GPU\n",
      "          @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "      @Expression <Alias> 2022-04-05 09:36:19.001066 AS now#439 could run on GPU\n",
      "        @Expression <Literal> 2022-04-05 09:36:19.001066 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:21,133 WARN rapids.GpuOverrides: \n",
      "  !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "    @Partitioning <RangePartitioning> could run on GPU\n",
      "      @Expression <SortOrder> customerID#395 ASC NULLS FIRST could run on GPU\n",
      "        @Expression <AttributeReference> customerID#395 could run on GPU\n",
      "    !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "      @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#395 could run on GPU\n",
      "        ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "          @Expression <Literal> %s-%s could run on GPU\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "      @Expression <Alias> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) AS dateOfBirth#460 could run on GPU\n",
      "        @Expression <DateSub> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) could run on GPU\n",
      "          @Expression <Literal> 2022-04-05 could run on GPU\n",
      "          @Expression <Cast> cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int) could run on GPU\n",
      "            @Expression <Floor> FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) could run on GPU\n",
      "              @Expression <CaseWhen> CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END could run on GPU\n",
      "                @Expression <EqualTo> (cast(SeniorCitizen#2 as int) = 0) could run on GPU\n",
      "                  @Expression <Cast> cast(SeniorCitizen#2 as int) could run on GPU\n",
      "                    @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                  @Expression <Literal> 0 could run on GPU\n",
      "                @Expression <Add> (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) could run on GPU\n",
      "                  @Expression <Multiply> ((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) could run on GPU\n",
      "                    @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                      @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                        @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                          @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                            @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                              ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                @Expression <Literal> %s-%s could run on GPU\n",
      "                                @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                          @Expression <Literal> 4096 could run on GPU\n",
      "                      @Expression <Literal> 4096.0 could run on GPU\n",
      "                    @Expression <Literal> 16801.5 could run on GPU\n",
      "                  @Expression <Literal> 6574.5 could run on GPU\n",
      "                @Expression <Add> (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) could run on GPU\n",
      "                  @Expression <Multiply> ((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) could run on GPU\n",
      "                    @Expression <Multiply> (-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) could run on GPU\n",
      "                      @Expression <UnaryMinus> -LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                        @Expression <Log1p> LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                          @Expression <UnaryMinus> -(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                            @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                              @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                                @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                                  @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                                    @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                                      ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                        @Expression <Literal> %s-%s could run on GPU\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                        @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                                  @Expression <Literal> 4096 could run on GPU\n",
      "                              @Expression <Literal> 4096.0 could run on GPU\n",
      "                      @Expression <Literal> 6.3 could run on GPU\n",
      "                    @Expression <Literal> 365.25 could run on GPU\n",
      "                  @Expression <Literal> 23741.25 could run on GPU\n",
      "      @Expression <AttributeReference> gender#1 could run on GPU\n",
      "      @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "      @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "      @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "      @Expression <Alias> cast(MonthlyCharges#18 as decimal(8,2)) AS MonthlyCharges#441 could run on GPU\n",
      "        @Expression <Cast> cast(MonthlyCharges#18 as decimal(8,2)) could run on GPU\n",
      "          @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "      @Expression <Alias> 2022-04-05 09:36:19.001066 AS now#439 could run on GPU\n",
      "        @Expression <Literal> 2022-04-05 09:36:19.001066 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:21,138 WARN rapids.GpuOverrides: \n",
      "  !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "    @Partitioning <RangePartitioning> could run on GPU\n",
      "      @Expression <SortOrder> customerID#395 ASC NULLS FIRST could run on GPU\n",
      "        @Expression <AttributeReference> customerID#395 could run on GPU\n",
      "    !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "      @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#395 could run on GPU\n",
      "        ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "          @Expression <Literal> %s-%s could run on GPU\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "      @Expression <Alias> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) AS dateOfBirth#460 could run on GPU\n",
      "        @Expression <DateSub> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) could run on GPU\n",
      "          @Expression <Literal> 2022-04-05 could run on GPU\n",
      "          @Expression <Cast> cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int) could run on GPU\n",
      "            @Expression <Floor> FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) could run on GPU\n",
      "              @Expression <CaseWhen> CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END could run on GPU\n",
      "                @Expression <EqualTo> (cast(SeniorCitizen#2 as int) = 0) could run on GPU\n",
      "                  @Expression <Cast> cast(SeniorCitizen#2 as int) could run on GPU\n",
      "                    @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                  @Expression <Literal> 0 could run on GPU\n",
      "                @Expression <Add> (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) could run on GPU\n",
      "                  @Expression <Multiply> ((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) could run on GPU\n",
      "                    @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                      @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                        @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                          @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                            @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                              ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                @Expression <Literal> %s-%s could run on GPU\n",
      "                                @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                          @Expression <Literal> 4096 could run on GPU\n",
      "                      @Expression <Literal> 4096.0 could run on GPU\n",
      "                    @Expression <Literal> 16801.5 could run on GPU\n",
      "                  @Expression <Literal> 6574.5 could run on GPU\n",
      "                @Expression <Add> (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) could run on GPU\n",
      "                  @Expression <Multiply> ((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) could run on GPU\n",
      "                    @Expression <Multiply> (-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) could run on GPU\n",
      "                      @Expression <UnaryMinus> -LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                        @Expression <Log1p> LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                          @Expression <UnaryMinus> -(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                            @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                              @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                                @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                                  @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                                    @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                                      ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                        @Expression <Literal> %s-%s could run on GPU\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                        @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                                  @Expression <Literal> 4096 could run on GPU\n",
      "                              @Expression <Literal> 4096.0 could run on GPU\n",
      "                      @Expression <Literal> 6.3 could run on GPU\n",
      "                    @Expression <Literal> 365.25 could run on GPU\n",
      "                  @Expression <Literal> 23741.25 could run on GPU\n",
      "      @Expression <AttributeReference> gender#1 could run on GPU\n",
      "      @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "      @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "      @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "      @Expression <Alias> cast(MonthlyCharges#18 as decimal(8,2)) AS MonthlyCharges#441 could run on GPU\n",
      "        @Expression <Cast> cast(MonthlyCharges#18 as decimal(8,2)) could run on GPU\n",
      "          @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "      @Expression <Alias> 2022-04-05 09:36:19.001066 AS now#439 could run on GPU\n",
      "        @Expression <Literal> 2022-04-05 09:36:19.001066 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:21,144 WARN rapids.GpuOverrides: \n",
      "  !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "    @Partitioning <RangePartitioning> could run on GPU\n",
      "      @Expression <SortOrder> customerID#395 ASC NULLS FIRST could run on GPU\n",
      "        @Expression <AttributeReference> customerID#395 could run on GPU\n",
      "    !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "      @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#395 could run on GPU\n",
      "        ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "          @Expression <Literal> %s-%s could run on GPU\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "      @Expression <Alias> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) AS dateOfBirth#460 could run on GPU\n",
      "        @Expression <DateSub> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) could run on GPU\n",
      "          @Expression <Literal> 2022-04-05 could run on GPU\n",
      "          @Expression <Cast> cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int) could run on GPU\n",
      "            @Expression <Floor> FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) could run on GPU\n",
      "              @Expression <CaseWhen> CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END could run on GPU\n",
      "                @Expression <EqualTo> (cast(SeniorCitizen#2 as int) = 0) could run on GPU\n",
      "                  @Expression <Cast> cast(SeniorCitizen#2 as int) could run on GPU\n",
      "                    @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                  @Expression <Literal> 0 could run on GPU\n",
      "                @Expression <Add> (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) could run on GPU\n",
      "                  @Expression <Multiply> ((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) could run on GPU\n",
      "                    @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                      @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                        @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                          @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                            @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                              ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                @Expression <Literal> %s-%s could run on GPU\n",
      "                                @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                          @Expression <Literal> 4096 could run on GPU\n",
      "                      @Expression <Literal> 4096.0 could run on GPU\n",
      "                    @Expression <Literal> 16801.5 could run on GPU\n",
      "                  @Expression <Literal> 6574.5 could run on GPU\n",
      "                @Expression <Add> (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) could run on GPU\n",
      "                  @Expression <Multiply> ((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) could run on GPU\n",
      "                    @Expression <Multiply> (-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) could run on GPU\n",
      "                      @Expression <UnaryMinus> -LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                        @Expression <Log1p> LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                          @Expression <UnaryMinus> -(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                            @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                              @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                                @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                                  @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                                    @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                                      ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                        @Expression <Literal> %s-%s could run on GPU\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                        @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                                  @Expression <Literal> 4096 could run on GPU\n",
      "                              @Expression <Literal> 4096.0 could run on GPU\n",
      "                      @Expression <Literal> 6.3 could run on GPU\n",
      "                    @Expression <Literal> 365.25 could run on GPU\n",
      "                  @Expression <Literal> 23741.25 could run on GPU\n",
      "      @Expression <AttributeReference> gender#1 could run on GPU\n",
      "      @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "      @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "      @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "      @Expression <Alias> cast(MonthlyCharges#18 as decimal(8,2)) AS MonthlyCharges#441 could run on GPU\n",
      "        @Expression <Cast> cast(MonthlyCharges#18 as decimal(8,2)) could run on GPU\n",
      "          @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "      @Expression <Alias> 2022-04-05 09:36:19.001066 AS now#439 could run on GPU\n",
      "        @Expression <Literal> 2022-04-05 09:36:19.001066 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:21,206 WARN rapids.GpuOverrides: \n",
      "  !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "    @Partitioning <RangePartitioning> could run on GPU\n",
      "      @Expression <SortOrder> customerID#395 ASC NULLS FIRST could run on GPU\n",
      "        @Expression <AttributeReference> customerID#395 could run on GPU\n",
      "    !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "      @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#395 could run on GPU\n",
      "        ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "          @Expression <Literal> %s-%s could run on GPU\n",
      "          @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "          @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "      @Expression <Alias> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) AS dateOfBirth#460 could run on GPU\n",
      "        @Expression <DateSub> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) could run on GPU\n",
      "          @Expression <Literal> 2022-04-05 could run on GPU\n",
      "          @Expression <Cast> cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int) could run on GPU\n",
      "            @Expression <Floor> FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) could run on GPU\n",
      "              @Expression <CaseWhen> CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END could run on GPU\n",
      "                @Expression <EqualTo> (cast(SeniorCitizen#2 as int) = 0) could run on GPU\n",
      "                  @Expression <Cast> cast(SeniorCitizen#2 as int) could run on GPU\n",
      "                    @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                  @Expression <Literal> 0 could run on GPU\n",
      "                @Expression <Add> (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) could run on GPU\n",
      "                  @Expression <Multiply> ((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) could run on GPU\n",
      "                    @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                      @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                        @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                          @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                            @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                              ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                @Expression <Literal> %s-%s could run on GPU\n",
      "                                @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                          @Expression <Literal> 4096 could run on GPU\n",
      "                      @Expression <Literal> 4096.0 could run on GPU\n",
      "                    @Expression <Literal> 16801.5 could run on GPU\n",
      "                  @Expression <Literal> 6574.5 could run on GPU\n",
      "                @Expression <Add> (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) could run on GPU\n",
      "                  @Expression <Multiply> ((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) could run on GPU\n",
      "                    @Expression <Multiply> (-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) could run on GPU\n",
      "                      @Expression <UnaryMinus> -LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                        @Expression <Log1p> LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                          @Expression <UnaryMinus> -(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                            @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                              @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                                @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                                  @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                                    @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                                      ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                        @Expression <Literal> %s-%s could run on GPU\n",
      "                                        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                        @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                                  @Expression <Literal> 4096 could run on GPU\n",
      "                              @Expression <Literal> 4096.0 could run on GPU\n",
      "                      @Expression <Literal> 6.3 could run on GPU\n",
      "                    @Expression <Literal> 365.25 could run on GPU\n",
      "                  @Expression <Literal> 23741.25 could run on GPU\n",
      "      @Expression <AttributeReference> gender#1 could run on GPU\n",
      "      @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "      @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "      @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "      @Expression <Alias> cast(MonthlyCharges#18 as decimal(8,2)) AS MonthlyCharges#441 could run on GPU\n",
      "        @Expression <Cast> cast(MonthlyCharges#18 as decimal(8,2)) could run on GPU\n",
      "          @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "      @Expression <Alias> 2022-04-05 09:36:19.001066 AS now#439 could run on GPU\n",
      "        @Expression <Literal> 2022-04-05 09:36:19.001066 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:21,209 WARN rapids.GpuOverrides: \n",
      "!Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "  @Partitioning <RangePartitioning> could run on GPU\n",
      "    @Expression <SortOrder> customerID#395 ASC NULLS FIRST could run on GPU\n",
      "      @Expression <AttributeReference> customerID#395 could run on GPU\n",
      "  !Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#395 could run on GPU\n",
      "      ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "        @Expression <Literal> %s-%s could run on GPU\n",
      "        @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "        @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "    @Expression <Alias> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) AS dateOfBirth#460 could run on GPU\n",
      "      @Expression <DateSub> date_sub(2022-04-05, cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int)) could run on GPU\n",
      "        @Expression <Literal> 2022-04-05 could run on GPU\n",
      "        @Expression <Cast> cast(FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) as int) could run on GPU\n",
      "          @Expression <Floor> FLOOR(CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END) could run on GPU\n",
      "            @Expression <CaseWhen> CASE WHEN (cast(SeniorCitizen#2 as int) = 0) THEN (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) ELSE (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) END could run on GPU\n",
      "              @Expression <EqualTo> (cast(SeniorCitizen#2 as int) = 0) could run on GPU\n",
      "                @Expression <Cast> cast(SeniorCitizen#2 as int) could run on GPU\n",
      "                  @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "                @Expression <Literal> 0 could run on GPU\n",
      "              @Expression <Add> (((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) + 6574.5) could run on GPU\n",
      "                @Expression <Multiply> ((cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) * 16801.5) could run on GPU\n",
      "                  @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                    @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                      @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                        @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                          @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                            ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                              @Expression <Literal> %s-%s could run on GPU\n",
      "                              @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                              @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                        @Expression <Literal> 4096 could run on GPU\n",
      "                    @Expression <Literal> 4096.0 could run on GPU\n",
      "                  @Expression <Literal> 16801.5 could run on GPU\n",
      "                @Expression <Literal> 6574.5 could run on GPU\n",
      "              @Expression <Add> (((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) + 23741.25) could run on GPU\n",
      "                @Expression <Multiply> ((-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) * 365.25) could run on GPU\n",
      "                  @Expression <Multiply> (-LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) * 6.3) could run on GPU\n",
      "                    @Expression <UnaryMinus> -LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                      @Expression <Log1p> LOG1P(-(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0)) could run on GPU\n",
      "                        @Expression <UnaryMinus> -(cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                          @Expression <Divide> (cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) / 4096.0) could run on GPU\n",
      "                            @Expression <Cast> cast((abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) as double) could run on GPU\n",
      "                              @Expression <Remainder> (abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) % 4096) could run on GPU\n",
      "                                @Expression <Abs> abs(hash(format_string(%s-%s, customerID#0, u_value#337), 42), false) could run on GPU\n",
      "                                  @Expression <Murmur3Hash> hash(format_string(%s-%s, customerID#0, u_value#337), 42) could run on GPU\n",
      "                                    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "                                      @Expression <Literal> %s-%s could run on GPU\n",
      "                                      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "                                      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "                                @Expression <Literal> 4096 could run on GPU\n",
      "                            @Expression <Literal> 4096.0 could run on GPU\n",
      "                    @Expression <Literal> 6.3 could run on GPU\n",
      "                  @Expression <Literal> 365.25 could run on GPU\n",
      "                @Expression <Literal> 23741.25 could run on GPU\n",
      "    @Expression <AttributeReference> gender#1 could run on GPU\n",
      "    @Expression <AttributeReference> SeniorCitizen#2 could run on GPU\n",
      "    @Expression <AttributeReference> Partner#3 could run on GPU\n",
      "    @Expression <AttributeReference> Dependents#4 could run on GPU\n",
      "    @Expression <Alias> cast(MonthlyCharges#18 as decimal(8,2)) AS MonthlyCharges#441 could run on GPU\n",
      "      @Expression <Cast> cast(MonthlyCharges#18 as decimal(8,2)) could run on GPU\n",
      "        @Expression <AttributeReference> MonthlyCharges#18 could run on GPU\n",
      "    @Expression <Alias> 2022-04-05 09:36:19.001066 AS now#439 could run on GPU\n",
      "      @Expression <Literal> 2022-04-05 09:36:19.001066 could run on GPU\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:40:23,697 WARN rapids.GpuOverrides:                   (0 + 1) / 1]\n",
      "  !Exec <AQEShuffleReadExec> cannot run on GPU because Unable to replace CustomShuffleReader due to child not being columnar\n",
      "\n",
      "2022-04-05 09:40:24,451 WARN rapids.GpuOverrides:                               \n",
      "! <LocalTableScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.LocalTableScanExec\n",
      "  @Expression <AttributeReference> name#894 could run on GPU\n",
      "  @Expression <AttributeReference> database#895 could run on GPU\n",
      "  @Expression <AttributeReference> description#896 could run on GPU\n",
      "  @Expression <AttributeReference> tableType#897 could run on GPU\n",
      "  @Expression <AttributeReference> isTemporary#898 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:24,499 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#910 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#479 could run on GPU\n",
      "  @Expression <AttributeReference> value#480 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:24,502 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#910 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#479 could run on GPU\n",
      "  @Expression <AttributeReference> value#480 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:24,504 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#910 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#479 could run on GPU\n",
      "  @Expression <AttributeReference> value#480 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:24,507 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#910 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#479 could run on GPU\n",
      "  @Expression <AttributeReference> value#480 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:24,555 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#910 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#479 could run on GPU\n",
      "  @Expression <AttributeReference> value#480 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:24,557 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#910 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#479 could run on GPU\n",
      "  @Expression <AttributeReference> value#480 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:25,815 WARN rapids.GpuOverrides:                               \n",
      "! <LocalTableScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.LocalTableScanExec\n",
      "  @Expression <AttributeReference> name#946 could run on GPU\n",
      "  @Expression <AttributeReference> database#947 could run on GPU\n",
      "  @Expression <AttributeReference> description#948 could run on GPU\n",
      "  @Expression <AttributeReference> tableType#949 could run on GPU\n",
      "  @Expression <AttributeReference> isTemporary#950 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:25,888 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#962 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#513 could run on GPU\n",
      "  @Expression <AttributeReference> value#514 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:25,894 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#962 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#513 could run on GPU\n",
      "  @Expression <AttributeReference> value#514 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:25,901 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#962 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#513 could run on GPU\n",
      "  @Expression <AttributeReference> value#514 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:25,907 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#962 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#513 could run on GPU\n",
      "  @Expression <AttributeReference> value#514 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:25,962 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#962 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#513 could run on GPU\n",
      "  @Expression <AttributeReference> value#514 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:25,967 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#0, u_value#337) AS customerID#962 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#0, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#0 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#513 could run on GPU\n",
      "  @Expression <AttributeReference> value#514 could run on GPU\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:40:28,911 WARN rapids.GpuOverrides:                               \n",
      "! <LocalTableScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.LocalTableScanExec\n",
      "  @Expression <AttributeReference> name#998 could run on GPU\n",
      "  @Expression <AttributeReference> database#999 could run on GPU\n",
      "  @Expression <AttributeReference> description#1000 could run on GPU\n",
      "  @Expression <AttributeReference> tableType#1001 could run on GPU\n",
      "  @Expression <AttributeReference> isTemporary#1002 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:28,964 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#721, u_value#337) AS customerID#1014 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#721, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#722 could run on GPU\n",
      "  @Expression <AttributeReference> value#723 could run on GPU\n",
      "      ! <RDDScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.RDDScanExec\n",
      "        @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "        @Expression <AttributeReference> feature#722 could run on GPU\n",
      "        @Expression <AttributeReference> value#723 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:28,967 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#721, u_value#337) AS customerID#1014 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#721, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#722 could run on GPU\n",
      "  @Expression <AttributeReference> value#723 could run on GPU\n",
      "      ! <RDDScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.RDDScanExec\n",
      "        @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "        @Expression <AttributeReference> feature#722 could run on GPU\n",
      "        @Expression <AttributeReference> value#723 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:28,970 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#721, u_value#337) AS customerID#1014 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#721, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#722 could run on GPU\n",
      "  @Expression <AttributeReference> value#723 could run on GPU\n",
      "      ! <RDDScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.RDDScanExec\n",
      "        @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "        @Expression <AttributeReference> feature#722 could run on GPU\n",
      "        @Expression <AttributeReference> value#723 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:28,973 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#721, u_value#337) AS customerID#1014 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#721, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#722 could run on GPU\n",
      "  @Expression <AttributeReference> value#723 could run on GPU\n",
      "      ! <RDDScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.RDDScanExec\n",
      "        @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "        @Expression <AttributeReference> feature#722 could run on GPU\n",
      "        @Expression <AttributeReference> value#723 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:29,023 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#721, u_value#337) AS customerID#1014 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#721, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#722 could run on GPU\n",
      "  @Expression <AttributeReference> value#723 could run on GPU\n",
      "      ! <RDDScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.RDDScanExec\n",
      "        @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "        @Expression <AttributeReference> feature#722 could run on GPU\n",
      "        @Expression <AttributeReference> value#723 could run on GPU\n",
      "\n",
      "2022-04-05 09:40:29,026 WARN rapids.GpuOverrides: \n",
      "!Exec <ProjectExec> cannot run on GPU because not all expressions can be replaced\n",
      "  @Expression <Alias> format_string(%s-%s, customerID#721, u_value#337) AS customerID#1014 could run on GPU\n",
      "    ! <FormatString> format_string(%s-%s, customerID#721, u_value#337) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.FormatString\n",
      "      @Expression <Literal> %s-%s could run on GPU\n",
      "      @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "      @Expression <AttributeReference> u_value#337 could run on GPU\n",
      "  @Expression <AttributeReference> feature#722 could run on GPU\n",
      "  @Expression <AttributeReference> value#723 could run on GPU\n",
      "      ! <RDDScanExec> cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.RDDScanExec\n",
      "        @Expression <AttributeReference> customerID#721 could run on GPU\n",
      "        @Expression <AttributeReference> feature#722 could run on GPU\n",
      "        @Expression <AttributeReference> value#723 could run on GPU\n",
      "\n",
      "[Stage 41:==================================================>     (10 + 1) / 11]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 214 ms, sys: 34 ms, total: 248 ms\n",
      "Wall time: 3min 54s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "from churn.augment import write_df\n",
    "\n",
    "write_df(billingEvents, \"billing_events\", partition_by=\"month\")\n",
    "write_df(customerMeta, \"customer_meta\", skip_replication=True)\n",
    "write_df(customerPhoneFeatures, \"customer_phone_features\")\n",
    "write_df(customerInternetFeatures.orderBy(\"customerID\"), \"customer_internet_features\")\n",
    "write_df(customerAccountFeatures, \"customer_account_features\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "billing_events 703200\n",
      "customer_meta 703200\n",
      "customer_phone_features 635200\n",
      "customer_internet_features 551200\n",
      "customer_account_features 703200\n"
     ]
    }
   ],
   "source": [
    "for f in [\"billing_events\", \"customer_meta\", \"customer_phone_features\", \"customer_internet_features\", \"customer_account_features\"]:\n",
    "    output_df = session.read.parquet(\"%s.parquet\" % f)\n",
    "    print(f, output_df.select(\"customerID\").distinct().count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "import pyspark.sql.functions as F\n",
    "from functools import reduce\n",
    "\n",
    "output_dfs = []\n",
    "\n",
    "for f in [\"billing_events\", \"customer_meta\", \"customer_phone_features\", \"customer_internet_features\", \"customer_account_features\"]:\n",
    "    output_dfs.append(\n",
    "        session.read.parquet(\"%s.parquet\" % f).select(\n",
    "            F.lit(f).alias(\"table\"),\n",
    "            \"customerID\"\n",
    "        )\n",
    "    )\n",
    "\n",
    "all_customers = reduce(lambda l, r: l.unionAll(r), output_dfs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:41:25,790 WARN rapids.GpuOverrides: \n",
      "!Exec <CollectLimitExec> cannot run on GPU because the Exec CollectLimitExec has been disabled, and is disabled by default because Collect Limit replacement can be slower on the GPU, if huge number of rows in a batch it could help by limiting the number of rows transferred from GPU to CPU. Set spark.rapids.sql.exec.CollectLimitExec to true if you wish to enable it\n",
      "  @Partitioning <SinglePartition$> could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) AS approx_unique_customers#2118 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "          @Partitioning <HashPartitioning> could run on GPU\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "          !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "            @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "              ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "                @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        @Expression <Alias> all AS table#2537 could run on GPU\n",
      "          @Expression <Literal> all could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) AS approx_unique_customers#2538 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "          @Partitioning <HashPartitioning> could run on GPU\n",
      "            @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "          !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "            @Expression <Alias> 0 AS 0#2539 could run on GPU\n",
      "              @Expression <Literal> 0 could run on GPU\n",
      "            @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "              ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "                @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1905L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1906L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1907L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1908L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1909L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1910L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1911L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1912L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1913L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1914L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1915L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1916L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1917L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1918L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1919L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1920L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1921L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1922L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1923L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1924L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1925L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1926L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1927L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1928L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1929L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1930L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1931L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1932L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1933L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1934L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1935L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1936L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1937L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1938L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1939L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1940L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1941L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1942L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1943L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1944L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1945L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1946L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1947L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1948L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1949L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1950L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1951L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1952L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1953L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1954L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1955L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1956L could run on GPU\n",
      "            @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1957L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1958L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1959L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1960L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1961L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1962L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1963L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1964L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1965L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1966L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1967L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1968L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1969L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1970L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1971L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1972L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1973L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1974L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1975L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1976L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1977L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1978L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1979L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1980L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1981L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1982L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1983L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1984L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1985L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1986L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1987L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1988L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1989L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1990L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1991L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1992L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1993L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1994L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1995L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1996L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1997L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1998L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1999L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#2000L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#2001L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#2002L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#2003L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#2004L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#2005L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#2006L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#2007L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#2008L could run on GPU\n",
      "\n",
      "2022-04-05 09:41:25,794 WARN rapids.GpuOverrides: \n",
      "!Exec <CollectLimitExec> cannot run on GPU because the Exec CollectLimitExec has been disabled, and is disabled by default because Collect Limit replacement can be slower on the GPU, if huge number of rows in a batch it could help by limiting the number of rows transferred from GPU to CPU. Set spark.rapids.sql.exec.CollectLimitExec to true if you wish to enable it\n",
      "  @Partitioning <SinglePartition$> could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) AS approx_unique_customers#2118 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "          @Partitioning <HashPartitioning> could run on GPU\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "          !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "            @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "              ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "                @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        @Expression <Alias> all AS table#2537 could run on GPU\n",
      "          @Expression <Literal> all could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) AS approx_unique_customers#2538 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "          @Partitioning <HashPartitioning> could run on GPU\n",
      "            @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "          !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "            @Expression <Alias> 0 AS 0#2539 could run on GPU\n",
      "              @Expression <Literal> 0 could run on GPU\n",
      "            @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "              ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "                @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1905L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1906L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1907L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1908L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1909L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1910L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1911L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1912L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1913L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1914L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1915L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1916L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1917L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1918L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1919L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1920L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1921L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1922L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1923L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1924L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1925L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1926L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1927L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1928L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1929L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1930L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1931L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1932L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1933L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1934L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1935L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1936L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1937L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1938L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1939L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1940L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1941L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1942L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1943L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1944L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1945L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1946L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1947L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1948L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1949L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1950L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1951L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1952L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1953L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1954L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1955L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1956L could run on GPU\n",
      "            @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1957L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1958L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1959L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1960L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1961L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1962L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1963L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1964L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1965L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1966L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1967L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1968L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1969L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1970L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1971L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1972L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1973L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1974L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1975L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1976L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1977L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1978L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1979L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1980L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1981L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1982L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1983L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1984L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1985L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1986L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1987L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1988L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1989L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1990L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1991L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1992L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1993L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1994L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1995L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1996L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1997L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1998L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1999L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#2000L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#2001L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#2002L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#2003L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#2004L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#2005L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#2006L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#2007L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#2008L could run on GPU\n",
      "\n",
      "2022-04-05 09:41:25,797 WARN rapids.GpuOverrides: \n",
      "!Exec <CollectLimitExec> cannot run on GPU because the Exec CollectLimitExec has been disabled, and is disabled by default because Collect Limit replacement can be slower on the GPU, if huge number of rows in a batch it could help by limiting the number of rows transferred from GPU to CPU. Set spark.rapids.sql.exec.CollectLimitExec to true if you wish to enable it\n",
      "  @Partitioning <SinglePartition$> could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) AS approx_unique_customers#2118 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "          @Partitioning <HashPartitioning> could run on GPU\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "          !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "            @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "              ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "                @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "            @Expression <AttributeReference> table#1189 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        @Expression <Alias> all AS table#2537 could run on GPU\n",
      "          @Expression <Literal> all could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) AS approx_unique_customers#2538 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "          @Partitioning <HashPartitioning> could run on GPU\n",
      "            @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "          !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "            @Expression <Alias> 0 AS 0#2539 could run on GPU\n",
      "              @Expression <Literal> 0 could run on GPU\n",
      "            @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "              ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "                @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1905L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1906L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1907L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1908L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1909L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1910L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1911L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1912L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1913L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1914L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1915L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1916L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1917L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1918L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1919L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1920L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1921L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1922L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1923L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1924L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1925L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1926L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1927L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1928L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1929L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1930L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1931L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1932L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1933L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1934L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1935L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1936L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1937L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1938L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1939L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1940L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1941L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1942L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1943L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1944L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1945L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1946L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1947L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#1948L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#1949L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#1950L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#1951L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#1952L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#1953L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#1954L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#1955L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#1956L could run on GPU\n",
      "            @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "            @Expression <AttributeReference> MS[0]#1957L could run on GPU\n",
      "            @Expression <AttributeReference> MS[1]#1958L could run on GPU\n",
      "            @Expression <AttributeReference> MS[2]#1959L could run on GPU\n",
      "            @Expression <AttributeReference> MS[3]#1960L could run on GPU\n",
      "            @Expression <AttributeReference> MS[4]#1961L could run on GPU\n",
      "            @Expression <AttributeReference> MS[5]#1962L could run on GPU\n",
      "            @Expression <AttributeReference> MS[6]#1963L could run on GPU\n",
      "            @Expression <AttributeReference> MS[7]#1964L could run on GPU\n",
      "            @Expression <AttributeReference> MS[8]#1965L could run on GPU\n",
      "            @Expression <AttributeReference> MS[9]#1966L could run on GPU\n",
      "            @Expression <AttributeReference> MS[10]#1967L could run on GPU\n",
      "            @Expression <AttributeReference> MS[11]#1968L could run on GPU\n",
      "            @Expression <AttributeReference> MS[12]#1969L could run on GPU\n",
      "            @Expression <AttributeReference> MS[13]#1970L could run on GPU\n",
      "            @Expression <AttributeReference> MS[14]#1971L could run on GPU\n",
      "            @Expression <AttributeReference> MS[15]#1972L could run on GPU\n",
      "            @Expression <AttributeReference> MS[16]#1973L could run on GPU\n",
      "            @Expression <AttributeReference> MS[17]#1974L could run on GPU\n",
      "            @Expression <AttributeReference> MS[18]#1975L could run on GPU\n",
      "            @Expression <AttributeReference> MS[19]#1976L could run on GPU\n",
      "            @Expression <AttributeReference> MS[20]#1977L could run on GPU\n",
      "            @Expression <AttributeReference> MS[21]#1978L could run on GPU\n",
      "            @Expression <AttributeReference> MS[22]#1979L could run on GPU\n",
      "            @Expression <AttributeReference> MS[23]#1980L could run on GPU\n",
      "            @Expression <AttributeReference> MS[24]#1981L could run on GPU\n",
      "            @Expression <AttributeReference> MS[25]#1982L could run on GPU\n",
      "            @Expression <AttributeReference> MS[26]#1983L could run on GPU\n",
      "            @Expression <AttributeReference> MS[27]#1984L could run on GPU\n",
      "            @Expression <AttributeReference> MS[28]#1985L could run on GPU\n",
      "            @Expression <AttributeReference> MS[29]#1986L could run on GPU\n",
      "            @Expression <AttributeReference> MS[30]#1987L could run on GPU\n",
      "            @Expression <AttributeReference> MS[31]#1988L could run on GPU\n",
      "            @Expression <AttributeReference> MS[32]#1989L could run on GPU\n",
      "            @Expression <AttributeReference> MS[33]#1990L could run on GPU\n",
      "            @Expression <AttributeReference> MS[34]#1991L could run on GPU\n",
      "            @Expression <AttributeReference> MS[35]#1992L could run on GPU\n",
      "            @Expression <AttributeReference> MS[36]#1993L could run on GPU\n",
      "            @Expression <AttributeReference> MS[37]#1994L could run on GPU\n",
      "            @Expression <AttributeReference> MS[38]#1995L could run on GPU\n",
      "            @Expression <AttributeReference> MS[39]#1996L could run on GPU\n",
      "            @Expression <AttributeReference> MS[40]#1997L could run on GPU\n",
      "            @Expression <AttributeReference> MS[41]#1998L could run on GPU\n",
      "            @Expression <AttributeReference> MS[42]#1999L could run on GPU\n",
      "            @Expression <AttributeReference> MS[43]#2000L could run on GPU\n",
      "            @Expression <AttributeReference> MS[44]#2001L could run on GPU\n",
      "            @Expression <AttributeReference> MS[45]#2002L could run on GPU\n",
      "            @Expression <AttributeReference> MS[46]#2003L could run on GPU\n",
      "            @Expression <AttributeReference> MS[47]#2004L could run on GPU\n",
      "            @Expression <AttributeReference> MS[48]#2005L could run on GPU\n",
      "            @Expression <AttributeReference> MS[49]#2006L could run on GPU\n",
      "            @Expression <AttributeReference> MS[50]#2007L could run on GPU\n",
      "            @Expression <AttributeReference> MS[51]#2008L could run on GPU\n",
      "\n",
      "2022-04-05 09:41:25,801 WARN util.package: Truncated the string representation of a plan since it was too large. This behavior can be adjusted by setting 'spark.sql.debug.maxToStringFields'.\n",
      "2022-04-05 09:41:25,806 WARN rapids.GpuOverrides: \n",
      "!Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "  @Partitioning <HashPartitioning> could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "\n",
      "2022-04-05 09:41:25,810 WARN rapids.GpuOverrides: \n",
      "!Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "  @Partitioning <HashPartitioning> could run on GPU\n",
      "    @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <Alias> 0 AS 0#2539 could run on GPU\n",
      "      @Expression <Literal> 0 could run on GPU\n",
      "    @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#1905L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#1906L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#1907L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#1908L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#1909L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#1910L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#1911L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#1912L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#1913L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#1914L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#1915L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#1916L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#1917L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#1918L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#1919L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#1920L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#1921L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#1922L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#1923L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#1924L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#1925L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#1926L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#1927L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#1928L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#1929L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#1930L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#1931L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#1932L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#1933L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#1934L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#1935L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#1936L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#1937L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#1938L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#1939L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#1940L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#1941L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#1942L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#1943L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#1944L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#1945L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#1946L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#1947L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#1948L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#1949L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#1950L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#1951L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#1952L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#1953L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#1954L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#1955L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#1956L could run on GPU\n",
      "    @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#1957L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#1958L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#1959L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#1960L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#1961L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#1962L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#1963L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#1964L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#1965L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#1966L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#1967L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#1968L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#1969L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#1970L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#1971L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#1972L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#1973L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#1974L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#1975L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#1976L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#1977L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#1978L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#1979L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#1980L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#1981L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#1982L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#1983L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#1984L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#1985L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#1986L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#1987L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#1988L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#1989L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#1990L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#1991L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#1992L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#1993L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#1994L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#1995L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#1996L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#1997L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#1998L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#1999L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#2000L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#2001L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#2002L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#2003L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#2004L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#2005L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#2006L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#2007L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#2008L could run on GPU\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:42:07,736 WARN rapids.GpuOverrides: >               (0 + 0) / 815]\n",
      "!Exec <CollectLimitExec> cannot run on GPU because the Exec CollectLimitExec has been disabled, and is disabled by default because Collect Limit replacement can be slower on the GPU, if huge number of rows in a batch it could help by limiting the number of rows transferred from GPU to CPU. Set spark.rapids.sql.exec.CollectLimitExec to true if you wish to enable it\n",
      "  @Partitioning <SinglePartition$> could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) AS approx_unique_customers#2118 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        @Expression <Alias> all AS table#2537 could run on GPU\n",
      "          @Expression <Literal> all could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) AS approx_unique_customers#2538 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "\n",
      "2022-04-05 09:42:46,961 WARN rapids.GpuOverrides: =============>(812 + 1) / 815]\n",
      "!Exec <CollectLimitExec> cannot run on GPU because the Exec CollectLimitExec has been disabled, and is disabled by default because Collect Limit replacement can be slower on the GPU, if huge number of rows in a batch it could help by limiting the number of rows transferred from GPU to CPU. Set spark.rapids.sql.exec.CollectLimitExec to true if you wish to enable it\n",
      "  @Partitioning <SinglePartition$> could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) AS approx_unique_customers#2118 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        @Expression <Alias> all AS table#2537 could run on GPU\n",
      "          @Expression <Literal> all could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) AS approx_unique_customers#2538 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "\n",
      "2022-04-05 09:42:46,964 WARN rapids.GpuOverrides: \n",
      "!Exec <CollectLimitExec> cannot run on GPU because the Exec CollectLimitExec has been disabled, and is disabled by default because Collect Limit replacement can be slower on the GPU, if huge number of rows in a batch it could help by limiting the number of rows transferred from GPU to CPU. Set spark.rapids.sql.exec.CollectLimitExec to true if you wish to enable it\n",
      "  @Partitioning <SinglePartition$> could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) AS approx_unique_customers#2118 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "        !Exec <AQEShuffleReadExec> cannot run on GPU because Unable to replace CustomShuffleReader due to child not being columnar\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> 0#2539 could run on GPU\n",
      "        @Expression <AggregateExpression> approx_count_distinct(customerID#1883, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1883, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1883 could run on GPU\n",
      "        @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        @Expression <Alias> all AS table#2537 could run on GPU\n",
      "          @Expression <Literal> all could run on GPU\n",
      "        @Expression <Alias> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) AS approx_unique_customers#2538 could run on GPU\n",
      "          @Expression <Cast> cast(approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L as string) could run on GPU\n",
      "            @Expression <AttributeReference> approx_count_distinct(customerID#1883, 0.05, 0, 0)#1671L could run on GPU\n",
      "        !Exec <AQEShuffleReadExec> cannot run on GPU because Unable to replace CustomShuffleReader due to child not being columnar\n",
      "\n",
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+-----------------------+\n",
      "|               table|approx_unique_customers|\n",
      "+--------------------+-----------------------+\n",
      "|      billing_events|                 699470|\n",
      "|       customer_meta|                 699470|\n",
      "|customer_phone_fe...|                 631148|\n",
      "|customer_internet...|                 521053|\n",
      "|customer_account_...|                 699470|\n",
      "|                 all|                 699470|\n",
      "+--------------------+-----------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "each_table = all_customers.groupBy(\"table\").agg(F.approx_count_distinct(\"customerID\").alias(\"approx_unique_customers\"))\n",
    "overall = all_customers.groupBy(F.lit(\"all\").alias(\"table\")).agg(F.approx_count_distinct(\"customerID\").alias(\"approx_unique_customers\"))\n",
    "\n",
    "each_table.union(overall).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:42:47,133 WARN rapids.GpuOverrides: \n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L AS approx_unique_customers#1353L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "      @Partitioning <HashPartitioning> could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    @Expression <Alias> all AS table#1564 could run on GPU\n",
      "      @Expression <Literal> all could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L AS approx_unique_customers#1672L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "      @Partitioning <HashPartitioning> could run on GPU\n",
      "        @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <Alias> 0 AS 0#4023 could run on GPU\n",
      "          @Expression <Literal> 0 could run on GPU\n",
      "        @Expression <AggregateExpression> partial_approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#3397L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#3398L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#3399L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#3400L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#3401L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#3402L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#3403L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#3404L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#3405L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#3406L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#3407L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#3408L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#3409L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#3410L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#3411L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#3412L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#3413L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#3414L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#3415L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#3416L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#3417L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#3418L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#3419L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#3420L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#3421L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#3422L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#3423L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#3424L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#3425L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#3426L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#3427L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#3428L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#3429L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#3430L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#3431L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#3432L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#3433L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#3434L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#3435L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#3436L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#3437L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#3438L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#3439L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#3440L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#3441L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#3442L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#3443L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#3444L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#3445L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#3446L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#3447L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#3448L could run on GPU\n",
      "        @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#3449L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#3450L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#3451L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#3452L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#3453L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#3454L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#3455L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#3456L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#3457L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#3458L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#3459L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#3460L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#3461L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#3462L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#3463L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#3464L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#3465L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#3466L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#3467L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#3468L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#3469L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#3470L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#3471L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#3472L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#3473L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#3474L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#3475L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#3476L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#3477L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#3478L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#3479L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#3480L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#3481L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#3482L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#3483L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#3484L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#3485L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#3486L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#3487L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#3488L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#3489L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#3490L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#3491L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#3492L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#3493L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#3494L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#3495L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#3496L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#3497L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#3498L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#3499L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#3500L could run on GPU\n",
      "\n",
      "2022-04-05 09:42:47,136 WARN rapids.GpuOverrides: \n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L AS approx_unique_customers#1353L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "      @Partitioning <HashPartitioning> could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    @Expression <Alias> all AS table#1564 could run on GPU\n",
      "      @Expression <Literal> all could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L AS approx_unique_customers#1672L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "      @Partitioning <HashPartitioning> could run on GPU\n",
      "        @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <Alias> 0 AS 0#4023 could run on GPU\n",
      "          @Expression <Literal> 0 could run on GPU\n",
      "        @Expression <AggregateExpression> partial_approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#3397L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#3398L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#3399L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#3400L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#3401L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#3402L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#3403L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#3404L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#3405L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#3406L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#3407L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#3408L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#3409L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#3410L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#3411L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#3412L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#3413L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#3414L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#3415L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#3416L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#3417L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#3418L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#3419L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#3420L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#3421L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#3422L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#3423L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#3424L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#3425L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#3426L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#3427L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#3428L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#3429L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#3430L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#3431L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#3432L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#3433L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#3434L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#3435L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#3436L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#3437L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#3438L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#3439L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#3440L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#3441L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#3442L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#3443L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#3444L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#3445L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#3446L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#3447L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#3448L could run on GPU\n",
      "        @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#3449L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#3450L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#3451L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#3452L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#3453L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#3454L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#3455L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#3456L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#3457L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#3458L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#3459L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#3460L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#3461L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#3462L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#3463L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#3464L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#3465L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#3466L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#3467L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#3468L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#3469L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#3470L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#3471L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#3472L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#3473L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#3474L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#3475L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#3476L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#3477L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#3478L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#3479L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#3480L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#3481L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#3482L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#3483L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#3484L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#3485L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#3486L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#3487L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#3488L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#3489L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#3490L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#3491L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#3492L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#3493L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#3494L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#3495L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#3496L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#3497L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#3498L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#3499L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#3500L could run on GPU\n",
      "\n",
      "2022-04-05 09:42:47,139 WARN rapids.GpuOverrides: \n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L AS approx_unique_customers#1353L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "      @Partitioning <HashPartitioning> could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "        @Expression <AttributeReference> table#1189 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    @Expression <Alias> all AS table#1564 could run on GPU\n",
      "      @Expression <Literal> all could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L AS approx_unique_customers#1672L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    !Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "      @Partitioning <HashPartitioning> could run on GPU\n",
      "        @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "      !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "        @Expression <Alias> 0 AS 0#4023 could run on GPU\n",
      "          @Expression <Literal> 0 could run on GPU\n",
      "        @Expression <AggregateExpression> partial_approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "          ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "            @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#3397L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#3398L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#3399L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#3400L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#3401L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#3402L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#3403L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#3404L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#3405L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#3406L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#3407L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#3408L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#3409L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#3410L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#3411L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#3412L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#3413L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#3414L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#3415L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#3416L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#3417L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#3418L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#3419L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#3420L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#3421L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#3422L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#3423L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#3424L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#3425L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#3426L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#3427L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#3428L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#3429L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#3430L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#3431L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#3432L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#3433L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#3434L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#3435L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#3436L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#3437L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#3438L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#3439L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#3440L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#3441L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#3442L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#3443L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#3444L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#3445L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#3446L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#3447L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#3448L could run on GPU\n",
      "        @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "        @Expression <AttributeReference> MS[0]#3449L could run on GPU\n",
      "        @Expression <AttributeReference> MS[1]#3450L could run on GPU\n",
      "        @Expression <AttributeReference> MS[2]#3451L could run on GPU\n",
      "        @Expression <AttributeReference> MS[3]#3452L could run on GPU\n",
      "        @Expression <AttributeReference> MS[4]#3453L could run on GPU\n",
      "        @Expression <AttributeReference> MS[5]#3454L could run on GPU\n",
      "        @Expression <AttributeReference> MS[6]#3455L could run on GPU\n",
      "        @Expression <AttributeReference> MS[7]#3456L could run on GPU\n",
      "        @Expression <AttributeReference> MS[8]#3457L could run on GPU\n",
      "        @Expression <AttributeReference> MS[9]#3458L could run on GPU\n",
      "        @Expression <AttributeReference> MS[10]#3459L could run on GPU\n",
      "        @Expression <AttributeReference> MS[11]#3460L could run on GPU\n",
      "        @Expression <AttributeReference> MS[12]#3461L could run on GPU\n",
      "        @Expression <AttributeReference> MS[13]#3462L could run on GPU\n",
      "        @Expression <AttributeReference> MS[14]#3463L could run on GPU\n",
      "        @Expression <AttributeReference> MS[15]#3464L could run on GPU\n",
      "        @Expression <AttributeReference> MS[16]#3465L could run on GPU\n",
      "        @Expression <AttributeReference> MS[17]#3466L could run on GPU\n",
      "        @Expression <AttributeReference> MS[18]#3467L could run on GPU\n",
      "        @Expression <AttributeReference> MS[19]#3468L could run on GPU\n",
      "        @Expression <AttributeReference> MS[20]#3469L could run on GPU\n",
      "        @Expression <AttributeReference> MS[21]#3470L could run on GPU\n",
      "        @Expression <AttributeReference> MS[22]#3471L could run on GPU\n",
      "        @Expression <AttributeReference> MS[23]#3472L could run on GPU\n",
      "        @Expression <AttributeReference> MS[24]#3473L could run on GPU\n",
      "        @Expression <AttributeReference> MS[25]#3474L could run on GPU\n",
      "        @Expression <AttributeReference> MS[26]#3475L could run on GPU\n",
      "        @Expression <AttributeReference> MS[27]#3476L could run on GPU\n",
      "        @Expression <AttributeReference> MS[28]#3477L could run on GPU\n",
      "        @Expression <AttributeReference> MS[29]#3478L could run on GPU\n",
      "        @Expression <AttributeReference> MS[30]#3479L could run on GPU\n",
      "        @Expression <AttributeReference> MS[31]#3480L could run on GPU\n",
      "        @Expression <AttributeReference> MS[32]#3481L could run on GPU\n",
      "        @Expression <AttributeReference> MS[33]#3482L could run on GPU\n",
      "        @Expression <AttributeReference> MS[34]#3483L could run on GPU\n",
      "        @Expression <AttributeReference> MS[35]#3484L could run on GPU\n",
      "        @Expression <AttributeReference> MS[36]#3485L could run on GPU\n",
      "        @Expression <AttributeReference> MS[37]#3486L could run on GPU\n",
      "        @Expression <AttributeReference> MS[38]#3487L could run on GPU\n",
      "        @Expression <AttributeReference> MS[39]#3488L could run on GPU\n",
      "        @Expression <AttributeReference> MS[40]#3489L could run on GPU\n",
      "        @Expression <AttributeReference> MS[41]#3490L could run on GPU\n",
      "        @Expression <AttributeReference> MS[42]#3491L could run on GPU\n",
      "        @Expression <AttributeReference> MS[43]#3492L could run on GPU\n",
      "        @Expression <AttributeReference> MS[44]#3493L could run on GPU\n",
      "        @Expression <AttributeReference> MS[45]#3494L could run on GPU\n",
      "        @Expression <AttributeReference> MS[46]#3495L could run on GPU\n",
      "        @Expression <AttributeReference> MS[47]#3496L could run on GPU\n",
      "        @Expression <AttributeReference> MS[48]#3497L could run on GPU\n",
      "        @Expression <AttributeReference> MS[49]#3498L could run on GPU\n",
      "        @Expression <AttributeReference> MS[50]#3499L could run on GPU\n",
      "        @Expression <AttributeReference> MS[51]#3500L could run on GPU\n",
      "\n",
      "2022-04-05 09:42:47,147 WARN rapids.GpuOverrides: \n",
      "!Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "  @Partitioning <HashPartitioning> could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> partial_approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#1354L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#1355L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#1356L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#1357L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#1358L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#1359L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#1360L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#1361L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#1362L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#1363L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#1364L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#1365L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#1366L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#1367L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#1368L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#1369L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#1370L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#1371L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#1372L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#1373L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#1374L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#1375L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#1376L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#1377L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#1378L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#1379L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#1380L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#1381L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#1382L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#1383L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#1384L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#1385L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#1386L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#1387L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#1388L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#1389L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#1390L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#1391L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#1392L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#1393L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#1394L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#1395L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#1396L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#1397L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#1398L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#1399L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#1400L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#1401L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#1402L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#1403L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#1404L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#1405L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#1406L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#1407L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#1408L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#1409L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#1410L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#1411L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#1412L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#1413L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#1414L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#1415L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#1416L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#1417L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#1418L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#1419L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#1420L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#1421L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#1422L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#1423L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#1424L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#1425L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#1426L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#1427L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#1428L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#1429L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#1430L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#1431L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#1432L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#1433L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#1434L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#1435L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#1436L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#1437L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#1438L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#1439L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#1440L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#1441L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#1442L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#1443L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#1444L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#1445L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#1446L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#1447L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#1448L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#1449L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#1450L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#1451L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#1452L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#1453L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#1454L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#1455L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#1456L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#1457L could run on GPU\n",
      "\n",
      "2022-04-05 09:42:47,151 WARN rapids.GpuOverrides: \n",
      "!Exec <ShuffleExchangeExec> cannot run on GPU because Columnar exchange without columnar children is inefficient\n",
      "  @Partitioning <HashPartitioning> could run on GPU\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <Alias> 0 AS 0#4023 could run on GPU\n",
      "      @Expression <Literal> 0 could run on GPU\n",
      "    @Expression <AggregateExpression> partial_approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#3397L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#3398L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#3399L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#3400L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#3401L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#3402L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#3403L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#3404L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#3405L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#3406L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#3407L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#3408L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#3409L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#3410L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#3411L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#3412L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#3413L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#3414L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#3415L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#3416L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#3417L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#3418L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#3419L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#3420L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#3421L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#3422L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#3423L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#3424L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#3425L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#3426L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#3427L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#3428L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#3429L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#3430L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#3431L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#3432L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#3433L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#3434L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#3435L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#3436L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#3437L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#3438L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#3439L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#3440L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#3441L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#3442L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#3443L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#3444L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#3445L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#3446L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#3447L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#3448L could run on GPU\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "    @Expression <AttributeReference> MS[0]#3449L could run on GPU\n",
      "    @Expression <AttributeReference> MS[1]#3450L could run on GPU\n",
      "    @Expression <AttributeReference> MS[2]#3451L could run on GPU\n",
      "    @Expression <AttributeReference> MS[3]#3452L could run on GPU\n",
      "    @Expression <AttributeReference> MS[4]#3453L could run on GPU\n",
      "    @Expression <AttributeReference> MS[5]#3454L could run on GPU\n",
      "    @Expression <AttributeReference> MS[6]#3455L could run on GPU\n",
      "    @Expression <AttributeReference> MS[7]#3456L could run on GPU\n",
      "    @Expression <AttributeReference> MS[8]#3457L could run on GPU\n",
      "    @Expression <AttributeReference> MS[9]#3458L could run on GPU\n",
      "    @Expression <AttributeReference> MS[10]#3459L could run on GPU\n",
      "    @Expression <AttributeReference> MS[11]#3460L could run on GPU\n",
      "    @Expression <AttributeReference> MS[12]#3461L could run on GPU\n",
      "    @Expression <AttributeReference> MS[13]#3462L could run on GPU\n",
      "    @Expression <AttributeReference> MS[14]#3463L could run on GPU\n",
      "    @Expression <AttributeReference> MS[15]#3464L could run on GPU\n",
      "    @Expression <AttributeReference> MS[16]#3465L could run on GPU\n",
      "    @Expression <AttributeReference> MS[17]#3466L could run on GPU\n",
      "    @Expression <AttributeReference> MS[18]#3467L could run on GPU\n",
      "    @Expression <AttributeReference> MS[19]#3468L could run on GPU\n",
      "    @Expression <AttributeReference> MS[20]#3469L could run on GPU\n",
      "    @Expression <AttributeReference> MS[21]#3470L could run on GPU\n",
      "    @Expression <AttributeReference> MS[22]#3471L could run on GPU\n",
      "    @Expression <AttributeReference> MS[23]#3472L could run on GPU\n",
      "    @Expression <AttributeReference> MS[24]#3473L could run on GPU\n",
      "    @Expression <AttributeReference> MS[25]#3474L could run on GPU\n",
      "    @Expression <AttributeReference> MS[26]#3475L could run on GPU\n",
      "    @Expression <AttributeReference> MS[27]#3476L could run on GPU\n",
      "    @Expression <AttributeReference> MS[28]#3477L could run on GPU\n",
      "    @Expression <AttributeReference> MS[29]#3478L could run on GPU\n",
      "    @Expression <AttributeReference> MS[30]#3479L could run on GPU\n",
      "    @Expression <AttributeReference> MS[31]#3480L could run on GPU\n",
      "    @Expression <AttributeReference> MS[32]#3481L could run on GPU\n",
      "    @Expression <AttributeReference> MS[33]#3482L could run on GPU\n",
      "    @Expression <AttributeReference> MS[34]#3483L could run on GPU\n",
      "    @Expression <AttributeReference> MS[35]#3484L could run on GPU\n",
      "    @Expression <AttributeReference> MS[36]#3485L could run on GPU\n",
      "    @Expression <AttributeReference> MS[37]#3486L could run on GPU\n",
      "    @Expression <AttributeReference> MS[38]#3487L could run on GPU\n",
      "    @Expression <AttributeReference> MS[39]#3488L could run on GPU\n",
      "    @Expression <AttributeReference> MS[40]#3489L could run on GPU\n",
      "    @Expression <AttributeReference> MS[41]#3490L could run on GPU\n",
      "    @Expression <AttributeReference> MS[42]#3491L could run on GPU\n",
      "    @Expression <AttributeReference> MS[43]#3492L could run on GPU\n",
      "    @Expression <AttributeReference> MS[44]#3493L could run on GPU\n",
      "    @Expression <AttributeReference> MS[45]#3494L could run on GPU\n",
      "    @Expression <AttributeReference> MS[46]#3495L could run on GPU\n",
      "    @Expression <AttributeReference> MS[47]#3496L could run on GPU\n",
      "    @Expression <AttributeReference> MS[48]#3497L could run on GPU\n",
      "    @Expression <AttributeReference> MS[49]#3498L could run on GPU\n",
      "    @Expression <AttributeReference> MS[50]#3499L could run on GPU\n",
      "    @Expression <AttributeReference> MS[51]#3500L could run on GPU\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 09:43:28,385 WARN rapids.GpuOverrides: >               (0 + 0) / 815]\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L AS approx_unique_customers#1353L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    @Expression <Alias> all AS table#1564 could run on GPU\n",
      "      @Expression <Literal> all could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L AS approx_unique_customers#1672L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "\n",
      "2022-04-05 09:44:07,480 WARN rapids.GpuOverrides: =============>(812 + 1) / 815]\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L AS approx_unique_customers#1353L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    @Expression <Alias> all AS table#1564 could run on GPU\n",
      "      @Expression <Literal> all could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L AS approx_unique_customers#1672L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "\n",
      "2022-04-05 09:44:07,482 WARN rapids.GpuOverrides: \n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#1179, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#1179, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#1179 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    @Expression <AttributeReference> table#1189 could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L AS approx_unique_customers#1353L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#1179, 0.05, 0, 0)#1352L could run on GPU\n",
      "    !Exec <AQEShuffleReadExec> cannot run on GPU because Unable to replace CustomShuffleReader due to child not being columnar\n",
      "  !Exec <HashAggregateExec> cannot run on GPU because not all expressions can be replaced\n",
      "    @Expression <AttributeReference> 0#4023 could run on GPU\n",
      "    @Expression <AggregateExpression> approx_count_distinct(customerID#3375, 0.05, 0, 0) could run on GPU\n",
      "      ! <HyperLogLogPlusPlus> approx_count_distinct(customerID#3375, 0.05, 0, 0) cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.catalyst.expressions.aggregate.HyperLogLogPlusPlus\n",
      "        @Expression <AttributeReference> customerID#3375 could run on GPU\n",
      "    @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    @Expression <Alias> all AS table#1564 could run on GPU\n",
      "      @Expression <Literal> all could run on GPU\n",
      "    @Expression <Alias> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L AS approx_unique_customers#1672L could run on GPU\n",
      "      @Expression <AttributeReference> approx_count_distinct(customerID#3375, 0.05, 0, 0)#1671L could run on GPU\n",
      "    !Exec <AQEShuffleReadExec> cannot run on GPU because Unable to replace CustomShuffleReader due to child not being columnar\n",
      "\n",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "rows = each_table.union(overall).collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'billing_events': 699470,\n",
       " 'customer_meta': 699470,\n",
       " 'customer_phone_features': 631148,\n",
       " 'customer_internet_features': 521053,\n",
       " 'customer_account_features': 699470,\n",
       " 'all': 699470}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict([(row[0], row[1]) for row in rows])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
